OTP-8568 RFC -5746

New ssl now supports secure renegotiation as described by RFC 5746.

9 files changed, 615 insertions, 247 deletions

diff --git a/lib/ssl/src/ssl.erl b/lib/ssl/src/ssl.erl
index 0ae3abfa37..95cd92ee60 100644
--- a/lib/ssl/src/ssl.erl
+++ b/lib/ssl/src/ssl.erl
@@ -154,7 +154,7 @@ transport_accept(#sslsocket{pid = {ListenSocket, #config{cb=CbInfo, ssl=SslOpts}
     EmOptions = emulated_options(),
     {ok, InetValues} = inet:getopts(ListenSocket, EmOptions),
     ok = inet:setopts(ListenSocket, internal_inet_values()),
-    {CbModule,_,_} = CbInfo,    
+    {CbModule,_,_, _} = CbInfo,    
     case CbModule:accept(ListenSocket, Timeout) of
 	{ok, Socket} ->
 	    ok = inet:setopts(ListenSocket, InetValues),
@@ -216,7 +216,7 @@ ssl_accept(Socket, SslOptions, Timeout) when is_port(Socket) ->
 %%
 %% Description: Close a ssl connection
 %%--------------------------------------------------------------------  
-close(#sslsocket{pid = {ListenSocket, #config{cb={CbMod,_, _}}}, fd = new_ssl}) ->
+close(#sslsocket{pid = {ListenSocket, #config{cb={CbMod,_, _, _}}}, fd = new_ssl}) ->
     CbMod:close(ListenSocket);
 close(#sslsocket{pid = Pid, fd = new_ssl}) ->
     ssl_connection:close(Pid);
@@ -375,7 +375,7 @@ setopts(#sslsocket{} = Socket, Options) ->
 %% 
 %% Description: Same as gen_tcp:shutdown/2
 %%--------------------------------------------------------------------
-shutdown(#sslsocket{pid = {ListenSocket, #config{cb={CbMod,_, _}}}, fd = new_ssl}, How) ->
+shutdown(#sslsocket{pid = {ListenSocket, #config{cb={CbMod,_, _, _}}}, fd = new_ssl}, How) ->
     CbMod:shutdown(ListenSocket, How);
 shutdown(#sslsocket{pid = Pid, fd = new_ssl}, How) ->
     ssl_connection:shutdown(Pid, How).
@@ -449,7 +449,7 @@ do_new_connect(Address, Port,
 	       #config{cb=CbInfo, inet_user=UserOpts, ssl=SslOpts,
 		       emulated=EmOpts,inet_ssl=SocketOpts},
 	       Timeout) ->
-    {CbModule, _, _} = CbInfo,    
+    {CbModule, _, _, _} = CbInfo,    
     try CbModule:connect(Address, Port,  SocketOpts, Timeout) of
 	{ok, Socket} ->
 	    ssl_connection:connect(Address, Port, Socket, {SslOpts,EmOpts},
@@ -471,7 +471,7 @@ old_connect(Address, Port, Options, Timeout) ->
 new_listen(Port, Options0) ->
     try 
 	{ok, Config} = handle_options(Options0, server),
-	#config{cb={CbModule, _, _},inet_user=Options} = Config,
+	#config{cb={CbModule, _, _, _},inet_user=Options} = Config,
 	case CbModule:listen(Port, Options) of
 	    {ok, ListenSocket} ->
 		{ok, #sslsocket{pid = {ListenSocket, Config}, fd = new_ssl}};
@@ -546,17 +546,18 @@ handle_options(Opts0, Role) ->
       %% Server side option
       reuse_session = handle_option(reuse_session, Opts, ReuseSessionFun),
       reuse_sessions = handle_option(reuse_sessions, Opts, true),
+      secure_renegotiate = handle_option(secure_renegotiate, Opts, false),
       renegotiate_at = handle_option(renegotiate_at, Opts, ?DEFAULT_RENEGOTIATE_AT),
       debug      = handle_option(debug, Opts, [])
      },
 
-    CbInfo  = proplists:get_value(cb_info, Opts, {gen_tcp, tcp, tcp_closed}),    
+    CbInfo  = proplists:get_value(cb_info, Opts, {gen_tcp, tcp, tcp_closed, tcp_error}),    
     SslOptions = [versions, verify, verify_fun, validate_extensions_fun, 
 		  fail_if_no_peer_cert, verify_client_once,
 		  depth, certfile, keyfile,
 		  key, password, cacertfile, dhfile, ciphers,
 		  debug, reuse_session, reuse_sessions, ssl_imp,
-		  cb_info, renegotiate_at],
+		  cb_info, renegotiate_at, secure_renegotiate],
     
     SockOpts = lists:foldl(fun(Key, PropList) -> 
 				   proplists:delete(Key, PropList)
@@ -627,6 +628,10 @@ validate_option(reuse_session, Value) when is_function(Value) ->
 validate_option(reuse_sessions, Value) when Value == true; 
 					    Value == false ->
     Value;
+
+validate_option(secure_renegotiate, Value) when Value == true; 
+						Value == false ->
+    Value;
 validate_option(renegotiate_at, Value) when is_integer(Value) ->
     min(Value, ?DEFAULT_RENEGOTIATE_AT);
 
@@ -735,24 +740,34 @@ cipher_suites(Version, Ciphers0)  ->
 
 format_error({error, Reason}) ->
     format_error(Reason);
+format_error(Reason) when is_list(Reason) ->
+    Reason;
 format_error(closed) ->
-    "Connection closed for the operation in question.";
+    "The connection is closed";
+format_error(ecacertfile) ->
+    "Own CA certificate file is invalid.";
+format_error(ecertfile) ->
+    "Own certificate file is invalid.";
+format_error(ekeyfile) ->
+    "Own private key file is invalid.";
+format_error(esslaccept) ->
+    "Server SSL handshake procedure between client and server failed.";
+format_error(esslconnect) ->
+    "Client SSL handshake procedure between client and server failed.";
+format_error({eoptions, Options}) ->
+    lists:flatten(io_lib:format("Error in options list: ~p~n", [Options]));
+
+%%%%%%%%%%%%  START OLD SSL format_error %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 format_error(ebadsocket) ->
     "Connection not found (internal error).";
 format_error(ebadstate) ->
     "Connection not in connect state (internal error).";
 format_error(ebrokertype) ->
     "Wrong broker type (internal error).";
-format_error(ecacertfile) ->
-    "Own CA certificate file is invalid.";
-format_error(ecertfile) ->
-    "Own certificate file is invalid.";
 format_error(echaintoolong) ->
     "The chain of certificates provided by peer is too long.";
 format_error(ecipher) ->
     "Own list of specified ciphers is invalid.";
-format_error(ekeyfile) ->
-    "Own private key file is invalid.";
 format_error(ekeymismatch) ->
     "Own private key does not match own certificate.";
 format_error(enoissuercert) ->
@@ -778,10 +793,6 @@ format_error(epeercertinvalid) ->
     "Certificate provided by peer is invalid.";
 format_error(eselfsignedcert) ->
     "Certificate provided by peer is self signed.";
-format_error(esslaccept) ->
-    "Server SSL handshake procedure between client and server failed.";
-format_error(esslconnect) ->
-    "Client SSL handshake procedure between client and server failed.";
 format_error(esslerrssl) ->
     "SSL protocol failure. Typically because of a fatal alert from peer.";
 format_error(ewantconnect) ->
@@ -800,6 +811,9 @@ format_error({badcast, _Cast}) ->
 format_error({badinfo, _Info}) ->
     "Call not recognized for current mode (active or passive) and state "
         "of socket.";
+
+%%%%%%%%%%%%%%%%%% END OLD SSL format_error %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
 format_error(Error) ->
     case (catch inet:format_error(Error)) of
         "unkknown POSIX" ++ _ ->
@@ -811,7 +825,7 @@ format_error(Error) ->
     end.
 
 no_format(Error) ->    
-    io_lib:format("No format string for error: \"~p\" available.", [Error]).
+    lists:flatten(io_lib:format("No format string for error: \"~p\" available.", [Error])).
 
 %% Start old ssl port program if needed.
 ensure_old_ssl_started() ->
diff --git a/lib/ssl/src/ssl_alert.erl b/lib/ssl/src/ssl_alert.erl
index d3f9c833f1..db9a883654 100644
--- a/lib/ssl/src/ssl_alert.erl
+++ b/lib/ssl/src/ssl_alert.erl
@@ -1,19 +1,19 @@
 %%
 %% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2007-2009. All Rights Reserved.
-%% 
+%%
+%% Copyright Ericsson AB 2007-2010. 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
 %% compliance with the License. You should have received a copy of the
 %% Erlang Public License along with this software. If not, it can be
 %% retrieved online at http://www.erlang.org/.
-%% 
+%%
 %% Software distributed under the License is distributed on an "AS IS"
 %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 %% the License for the specific language governing rights and limitations
 %% under the License.
-%% 
+%%
 %% %CopyrightEnd%
 %%
 
@@ -38,10 +38,6 @@ reason_code(#alert{description = ?HANDSHAKE_FAILURE}, client) ->
     esslconnect;
 reason_code(#alert{description = ?HANDSHAKE_FAILURE}, server) ->
     esslaccept;
-reason_code(#alert{description = ?CERTIFICATE_EXPIRED}, _) ->
-    epeercertexpired;
-reason_code(#alert{level = ?FATAL}, _) ->
-    esslerrssl;
 reason_code(#alert{description = Description}, _) ->
     description_txt(Description).
 
@@ -55,51 +51,51 @@ level_txt(?FATAL) ->
     "Fatal error:".
 
 description_txt(?CLOSE_NOTIFY) ->
-    "close_notify";
+    "close notify";
 description_txt(?UNEXPECTED_MESSAGE) ->
-    "unexpected_message";
+    "unexpected message";
 description_txt(?BAD_RECORD_MAC) ->
-    "bad_record_mac";
+    "bad record mac";
 description_txt(?DECRYPTION_FAILED) ->
-    "decryption_failed";
+    "decryption failed";
 description_txt(?RECORD_OVERFLOW) ->
-    "record_overflow";
+    "record overflow";
 description_txt(?DECOMPRESSION_FAILURE) ->
-    "decompression_failure";
+    "decompression failure";
 description_txt(?HANDSHAKE_FAILURE) ->
-    "handshake_failure";
+    "handshake failure";
 description_txt(?BAD_CERTIFICATE) ->
-    "bad_certificate";
+    "bad certificate";
 description_txt(?UNSUPPORTED_CERTIFICATE) ->
-    "unsupported_certificate";
+    "unsupported certificate";
 description_txt(?CERTIFICATE_REVOKED) ->
-    "certificate_revoked";
+    "certificate revoked";
 description_txt(?CERTIFICATE_EXPIRED) ->
-    "certificate_expired";
+    "certificate expired";
 description_txt(?CERTIFICATE_UNKNOWN) ->
-    "certificate_unknown";
+    "certificate unknown";
 description_txt(?ILLEGAL_PARAMETER) ->
-    "illegal_parameter";
+    "illegal parameter";
 description_txt(?UNKNOWN_CA) ->
-    "unknown_ca";
+    "unknown ca";
 description_txt(?ACCESS_DENIED) ->
-    "access_denied";
+    "access denied";
 description_txt(?DECODE_ERROR) ->
-    "decode_error";
+    "decode error";
 description_txt(?DECRYPT_ERROR) ->
-    "decrypt_error";
+    "decrypt error";
 description_txt(?EXPORT_RESTRICTION) ->
-    "export_restriction";
+    "export restriction";
 description_txt(?PROTOCOL_VERSION) ->
-    "protocol_version";
+    "protocol version";
 description_txt(?INSUFFICIENT_SECURITY) ->
-    "insufficient_security";
+    "insufficient security";
 description_txt(?INTERNAL_ERROR) ->
-    "internal_error";
+    "internal error";
 description_txt(?USER_CANCELED) ->
-    "user_canceled";
+    "user canceled";
 description_txt(?NO_RENEGOTIATION) ->
-    "no_renegotiation".
+    "no renegotiation".
 
 
 
diff --git a/lib/ssl/src/ssl_cipher.hrl b/lib/ssl/src/ssl_cipher.hrl
index 4304c501b7..d282cbd780 100644
--- a/lib/ssl/src/ssl_cipher.hrl
+++ b/lib/ssl/src/ssl_cipher.hrl
@@ -1,19 +1,19 @@
 %%
 %% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2007-2009. All Rights Reserved.
-%% 
+%%
+%% Copyright Ericsson AB 2007-2010. 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
 %% compliance with the License. You should have received a copy of the
 %% Erlang Public License along with this software. If not, it can be
 %% retrieved online at http://www.erlang.org/.
-%% 
+%%
 %% Software distributed under the License is distributed on an "AS IS"
 %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 %% the License for the specific language governing rights and limitations
 %% under the License.
-%% 
+%%
 %% %CopyrightEnd%
 %%
 
@@ -250,4 +250,9 @@
 -define(TLS_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA, <<?BYTE(16#00), ?BYTE(16#65)>>).
 -define(TLS_DHE_DSS_WITH_RC4_128_SHA, <<?BYTE(16#00), ?BYTE(16#66)>>).
 
+%% RFC 5746 - Not a real ciphersuite used to signal empty "renegotiation_info" extension
+%% to avoid handshake failure from old servers that do not ignore
+%% hello extension data as they should.
+-define(TLS_EMPTY_RENEGOTIATION_INFO_SCSV, <<?BYTE(16#00), ?BYTE(16#FF)>>).
+
 -endif. % -ifdef(ssl_cipher).
diff --git a/lib/ssl/src/ssl_connection.erl b/lib/ssl/src/ssl_connection.erl
index a406e86bbf..a9ddc44edf 100644
--- a/lib/ssl/src/ssl_connection.erl
+++ b/lib/ssl/src/ssl_connection.erl
@@ -58,6 +58,7 @@
           transport_cb,       % atom() - callback module 
           data_tag,           % atom()  - ex tcp.
 	  close_tag,          % atom()  - ex tcp_closed
+	  error_tag,          % atom() - ex  tcp_error
           host,               % string() | ipadress()
           port,               % integer()
           socket,             % socket() 
@@ -316,12 +317,14 @@ init([Role, Host, Port, Socket, {SSLOpts, _} = Options,
 %%
 %%--------------------------------------------------------------------
 hello(start, #state{host = Host, port = Port, role = client,
-			     ssl_options = SslOpts, 
-			     transport_cb = Transport, socket = Socket,
-			     connection_states = ConnectionStates}
+		    ssl_options = SslOpts, 
+		    transport_cb = Transport, socket = Socket,
+		    connection_states = ConnectionStates,
+		    renegotiation = {Renegotiation, _}}
       = State0) ->
     Hello = ssl_handshake:client_hello(Host, Port, 
-				       ConnectionStates, SslOpts),
+				       ConnectionStates, SslOpts, Renegotiation),
+
     Version = Hello#client_hello.client_version,
     Hashes0 = ssl_handshake:init_hashes(),
     {BinMsg, CS2, Hashes1} = 
@@ -351,55 +354,60 @@ hello(#server_hello{cipher_suite = CipherSuite,
 	     role = client,
 	     negotiated_version = ReqVersion,
 	     host = Host, port = Port,
+	     renegotiation = {Renegotiation, _},
+	     ssl_options = SslOptions,
 	     session_cache = Cache,
 	     session_cache_cb = CacheCb} = State0) ->
 
-    {Version, NewId, ConnectionStates1} =
-        ssl_handshake:hello(Hello, ConnectionStates0),
-
-    {KeyAlgorithm, _, _, _} = 
-        ssl_cipher:suite_definition(CipherSuite),
-    
-    PremasterSecret = make_premaster_secret(ReqVersion, KeyAlgorithm),
-    
-    State1 = State0#state{key_algorithm = KeyAlgorithm,
-			 negotiated_version = Version,
-			 connection_states = ConnectionStates1,
-			 premaster_secret = PremasterSecret},
-
-    case ssl_session:is_new(OldId, NewId) of
-        true ->
-	    Session = Session0#session{session_id = NewId,
-				       cipher_suite = CipherSuite,
+    case ssl_handshake:hello(Hello, SslOptions, ConnectionStates0, Renegotiation) of
+	{Version, NewId, ConnectionStates1} ->
+	    {KeyAlgorithm, _, _, _} = 
+		ssl_cipher:suite_definition(CipherSuite),
+	    
+	    PremasterSecret = make_premaster_secret(ReqVersion, KeyAlgorithm),
+	    
+	    State1 = State0#state{key_algorithm = KeyAlgorithm,
+				  negotiated_version = Version,
+				  connection_states = ConnectionStates1,
+				  premaster_secret = PremasterSecret},
+	    
+	    case ssl_session:is_new(OldId, NewId) of
+		true ->
+		    Session = Session0#session{session_id = NewId,
+					       cipher_suite = CipherSuite,
 				       compression_method = Compression}, 
-	    {Record, State} = next_record(State1#state{session = Session}),
-	    next_state(certify, Record, State);
-        false ->
-	    Session = CacheCb:lookup(Cache, {{Host, Port}, NewId}),
-	    case ssl_handshake:master_secret(Version, Session, 
-					     ConnectionStates1, client) of
-		{_, ConnectionStates2} ->	
-		    {Record, State} = 
-			next_record(State1#state{
-				      connection_states = ConnectionStates2,
-				      session = Session}),
-		    next_state(abbreviated, Record, State);
-		#alert{} = Alert ->
-		    handle_own_alert(Alert, Version, hello, State1), 
-		    {stop, normal, State1}
-	    end
+		    {Record, State} = next_record(State1#state{session = Session}),
+		    next_state(certify, Record, State);
+		false ->
+		    Session = CacheCb:lookup(Cache, {{Host, Port}, NewId}),
+		    case ssl_handshake:master_secret(Version, Session, 
+						     ConnectionStates1, client) of
+			{_, ConnectionStates2} ->	
+			    {Record, State} = 
+				next_record(State1#state{
+					      connection_states = ConnectionStates2,
+					      session = Session}),
+			    next_state(abbreviated, Record, State);
+			#alert{} = Alert ->
+			    handle_own_alert(Alert, Version, hello, State1), 
+			    {stop, normal, State1}
+		    end
+	    end;
+	#alert{} = Alert ->
+	    handle_own_alert(Alert, ReqVersion, hello, State0), 
+            {stop, normal, State0}
     end;
 
 hello(Hello = #client_hello{client_version = ClientVersion}, 
       State = #state{connection_states = ConnectionStates0,
 		     port = Port, session = Session0,
-		     session_cache = Cache,
+		     renegotiation = {Renegotiation, _},
+		     session_cache = Cache,		  
 		     session_cache_cb = CacheCb,
 		     ssl_options = SslOpts}) ->
     
-    case ssl_handshake:hello(Hello, {Port, SslOpts,  
-				     Session0, Cache, CacheCb,
-				     ConnectionStates0}) of
+    case ssl_handshake:hello(Hello, SslOpts, {Port, Session0, Cache, CacheCb,
+				     ConnectionStates0}, Renegotiation) of
         {Version, {Type, Session}, ConnectionStates} ->       
             do_server_hello(Type, State#state{connection_states  = 
 					      ConnectionStates,
@@ -417,29 +425,35 @@ abbreviated(#hello_request{}, State0) ->
     {Record, State} = next_record(State0),
     next_state(hello, Record, State);
 
-abbreviated(Finished = #finished{},
+abbreviated(Finished = #finished{verify_data = Data},
 	    #state{role = server,
 		   negotiated_version = Version,
 		   tls_handshake_hashes = Hashes,
-		   session = #session{master_secret = MasterSecret}} = 
+		   session = #session{master_secret = MasterSecret},
+		  connection_states = ConnectionStates0} = 
 	    State) ->
     case ssl_handshake:verify_connection(Version, Finished, client,
 					 MasterSecret, Hashes) of
         verified ->  
-	    next_state_connection(abbreviated, ack_connection(State));
+	    ConnectionStates = ssl_record:set_client_verify_data(current_both, Data, ConnectionStates0),
+	    next_state_connection(abbreviated, 
+				  ack_connection(State#state{connection_states = ConnectionStates}));
 	#alert{} = Alert ->
 	    handle_own_alert(Alert, Version, abbreviated, State),
             {stop, normal, State} 
     end;
 
-abbreviated(Finished = #finished{},
+abbreviated(Finished = #finished{verify_data = Data},
 	    #state{role = client, tls_handshake_hashes = Hashes0,
 		   session = #session{master_secret = MasterSecret},
-		   negotiated_version = Version} = State) ->
+		   negotiated_version = Version,
+		   connection_states = ConnectionStates0} = State) ->
     case ssl_handshake:verify_connection(Version, Finished, server,
 					 MasterSecret, Hashes0) of
         verified ->
-	    {ConnectionStates, Hashes} = finalize_client_handshake(State),
+	    ConnectionStates1 = ssl_record:set_server_verify_data(current_read, Data, ConnectionStates0),
+	    {ConnectionStates, Hashes} = 
+		finalize_handshake(State#state{connection_states = ConnectionStates1}, abbreviated),
 	    next_state_connection(abbreviated, 
 				  ack_connection(State#state{tls_handshake_hashes = Hashes,
 							     connection_states = 
@@ -653,32 +667,37 @@ cipher(#certificate_verify{signature = Signature},
 	    {stop, normal, State0}
     end;
 
-cipher(#finished{} = Finished, 
+cipher(#finished{verify_data = Data} = Finished, 
        #state{negotiated_version = Version,
 	      host = Host,
 	      port = Port,
 	      role = Role,
 	      session = #session{master_secret = MasterSecret} 
 	      = Session0,
-	      tls_handshake_hashes = Hashes} = State) ->    
+	      tls_handshake_hashes = Hashes0,
+	     connection_states = ConnectionStates0} = State) ->    
     
     case ssl_handshake:verify_connection(Version, Finished, 
 					 opposite_role(Role), 
-                                         MasterSecret, Hashes) of
+                                         MasterSecret, Hashes0) of
         verified ->
 	    Session = register_session(Role, Host, Port, Session0),
             case Role of
                 client ->
-                    next_state_connection(cipher, ack_connection(State#state{session = Session}));
+		    ConnectionStates = ssl_record:set_server_verify_data(current_both, Data, ConnectionStates0),
+                    next_state_connection(cipher, ack_connection(State#state{session = Session,
+									     connection_states = ConnectionStates}));
                 server ->
-                    {NewConnectionStates, NewHashes} = 
-                        finalize_server_handshake(State#state{
-						    session = Session}),
+		    ConnectionStates1 = ssl_record:set_client_verify_data(current_read, Data, ConnectionStates0),
+                    {ConnectionStates, Hashes} = 
+                        finalize_handshake(State#state{ 
+						    connection_states = ConnectionStates1,
+						    session = Session}, cipher),
                     next_state_connection(cipher, ack_connection(State#state{connection_states = 
-									     NewConnectionStates,
+									     ConnectionStates,
 									     session = Session,
 									     tls_handshake_hashes =
-									     NewHashes}))
+									     Hashes}))
             end;
         #alert{} = Alert ->
 	    handle_own_alert(Alert, Version, cipher, State),
@@ -695,10 +714,12 @@ connection(#hello_request{}, #state{host = Host, port = Port,
 				    negotiated_version = Version,
 				    transport_cb = Transport,
 				    connection_states = ConnectionStates0,
+				    renegotiation = {Renegotiation, _},
 				    tls_handshake_hashes = Hashes0} = State0) ->
-    
+   
     Hello = ssl_handshake:client_hello(Host, Port, 
-				       ConnectionStates0, SslOpts),
+				       ConnectionStates0, SslOpts, Renegotiation),
+  
     {BinMsg, ConnectionStates1, Hashes1} =
         encode_handshake(Hello, Version, ConnectionStates0, Hashes0),
     Transport:send(Socket, BinMsg),
@@ -913,14 +934,9 @@ handle_sync_event(peer_certificate, _, StateName,
 %% raw data from TCP, unpack records
 handle_info({Protocol, _, Data}, StateName,
             #state{data_tag = Protocol,
-		   negotiated_version = Version,
-                   tls_record_buffer = Buf0,
-                   tls_cipher_texts = CT0} = State0) ->
-    case ssl_record:get_tls_records(Data, Buf0) of
-	{Records, Buf1} ->
-	    CT1 = CT0 ++ Records,
-	    {Record, State} = next_record(State0#state{tls_record_buffer = Buf1,
-						       tls_cipher_texts = CT1}),
+		   negotiated_version = Version} = State0) ->
+    case next_tls_record(Data, State0) of
+	{Record, State} ->
 	    next_state(StateName, Record, State);
 	#alert{} = Alert ->
 	    handle_own_alert(Alert, Version, StateName, State0), 
@@ -944,14 +960,29 @@ handle_info({CloseTag, Socket}, _StateName,
     alert_user(Opts#socket_options.active, Pid, From,
 	       ?ALERT_REC(?WARNING, ?CLOSE_NOTIFY), Role),
     {stop, normal, State};
- 
+
+handle_info({ErrorTag, Socket, econnaborted}, StateName,  
+	    #state{socket = Socket, from = User, role = Role, 
+		   error_tag = ErrorTag} = State)  when StateName =/= connection ->
+    alert_user(User, ?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE), Role),
+    {stop, normal, State};
+
+handle_info({ErrorTag, Socket, Reason}, _,  
+	    #state{socket = Socket, from = User, 
+		   role = Role, error_tag = ErrorTag} = State)  ->
+    Report = io_lib:format("SSL: Socket error: ~p ~n", [Reason]),
+    error_logger:info_report(Report),
+    alert_user(User,  ?ALERT_REC(?FATAL, ?CLOSE_NOTIFY), Role),
+    {stop, normal, State};
+
 handle_info({'DOWN', MonitorRef, _, _, _}, _, 
 	    State = #state{user_application={MonitorRef,_Pid}}) ->
     {stop, normal, State};   
 
-handle_info(A, StateName, State) ->
-    io:format("SSL: Bad info (state ~w): ~w\n", [StateName, A]),
-    {stop, bad_info, State}.
+handle_info(Msg, StateName, State) ->
+    Report = io_lib:format("SSL: Got unexpected info: ~p ~n", [Msg]),
+    error_logger:info_report(Report),
+    {next_state, StateName, State}.
 
 %%--------------------------------------------------------------------
 %% Function: terminate(Reason, StateName, State) -> void()
@@ -970,14 +1001,14 @@ terminate(_Reason, connection, #state{negotiated_version = Version,
     {BinAlert, _} = encode_alert(?ALERT_REC(?WARNING,?CLOSE_NOTIFY),
 				 Version, ConnectionStates),
     Transport:send(Socket, BinAlert),
-    Transport:shutdown(Socket, read_write),
+    workaround_transport_delivery_problems(Socket, Transport),
     Transport:close(Socket);
 terminate(_Reason, _StateName, #state{transport_cb = Transport, 
 				      socket = Socket, send_queue = SendQueue,
 				      renegotiation = Renegotiate}) ->
     notify_senders(SendQueue),
     notify_renegotiater(Renegotiate),
-    Transport:shutdown(Socket, read_write),
+    workaround_transport_delivery_problems(Socket, Transport),
     Transport:close(Socket).
 
 %%--------------------------------------------------------------------
@@ -991,7 +1022,7 @@ code_change(_OldVsn, StateName, State, _Extra) ->
 %%--------------------------------------------------------------------
 %%% Internal functions
 %%--------------------------------------------------------------------
-start_fsm(Role, Host, Port, Socket, Opts,  User, {CbModule, _,_} = CbInfo, 
+start_fsm(Role, Host, Port, Socket, Opts,  User, {CbModule, _,_, _} = CbInfo, 
 	  Timeout) -> 
     case ssl_connection_sup:start_child([Role, Host, Port, Socket, 
                                          Opts, User, CbInfo]) of
@@ -1106,7 +1137,7 @@ init_diffie_hellman(DHParamFile, server) ->
     end.
 
 sync_send_all_state_event(FsmPid, Event) ->
-    sync_send_all_state_event(FsmPid, Event, ?DEFAULT_TIMEOUT).
+    sync_send_all_state_event(FsmPid, Event, infinity).
 
 sync_send_all_state_event(FsmPid, Event, Timeout) ->
     try gen_fsm:sync_send_all_state_event(FsmPid, Event, Timeout)
@@ -1175,32 +1206,34 @@ verify_client_cert(#state{client_certificate_requested = false} = State) ->
 
 do_server_hello(Type, #state{negotiated_version = Version,
 			     session = Session,
-			     connection_states = ConnectionStates0} 
+			     connection_states = ConnectionStates0,
+			     renegotiation = {Renegotiation, _}} 
 		= State0) when is_atom(Type) -> 
     ServerHello = 
         ssl_handshake:server_hello(Session#session.session_id, Version, 
-                                   ConnectionStates0),
-    State = server_hello(ServerHello, State0),
+                                   ConnectionStates0, Renegotiation),
+    State1 = server_hello(ServerHello, State0),
     
     case Type of	
 	new ->
-	    do_server_hello(ServerHello, State);
+	    do_server_hello(ServerHello, State1);
 	resumed ->
+	    ConnectionStates1 = State1#state.connection_states,
 	    case ssl_handshake:master_secret(Version, Session,
-					     ConnectionStates0, server) of
-		{_, ConnectionStates1} ->
-		    State1 = State#state{connection_states=ConnectionStates1, 
-					 session = Session},
+					     ConnectionStates1, server) of
+		{_, ConnectionStates2} ->
+		    State2 = State1#state{connection_states=ConnectionStates2, 
+					  session = Session},		    
 		    {ConnectionStates, Hashes} = 
-			finalize_server_handshake(State1),
-		    Resumed0 = State1#state{connection_states = 
-					   ConnectionStates,
-					   tls_handshake_hashes = Hashes},
-		    {Record, Resumed} = next_record(Resumed0),
-		    next_state(abbreviated, Record, Resumed);
+			finalize_handshake(State2, abbreviated),
+		    State3 = State2#state{connection_states = 
+					  ConnectionStates,
+					  tls_handshake_hashes = Hashes},
+		    {Record, State} = next_record(State3),
+		    next_state(abbreviated, Record, State);
 		#alert{} = Alert ->
-		    handle_own_alert(Alert, Version, hello, State), 
-		    {stop, normal, State}
+		    handle_own_alert(Alert, Version, hello, State1), 
+		    {stop, normal, State1}
 	    end
     end;
 
@@ -1228,7 +1261,7 @@ client_certify_and_key_exchange(#state{negotiated_version = Version} =
 				State0) ->
     try do_client_certify_and_key_exchange(State0) of 
         State1 = #state{} ->
-	    {ConnectionStates, Hashes} = finalize_client_handshake(State1),
+	    {ConnectionStates, Hashes} = finalize_handshake(State1, certify),
             State2 = State1#state{connection_states = ConnectionStates,
 				 %% Reinitialize 
 				 client_certificate_requested = false,
@@ -1439,45 +1472,44 @@ request_client_cert(#state{ssl_options = #ssl_options{verify = verify_none}} =
 		    State) ->
     State.
 
-finalize_client_handshake(#state{connection_states = ConnectionStates0} 
-                          = State) ->
-    ConnectionStates1 = 
-        cipher_protocol(State#state{connection_states = 
-                                    ConnectionStates0}),    
-    ConnectionStates2 =
-        ssl_record:activate_pending_connection_state(ConnectionStates1,
+finalize_handshake(State, StateName) ->
+    ConnectionStates0 = cipher_protocol(State),    
+    ConnectionStates =
+        ssl_record:activate_pending_connection_state(ConnectionStates0,
                                                      write),
-    finished(State#state{connection_states = ConnectionStates2}).
+    finished(State#state{connection_states = ConnectionStates}, StateName).
     
-
-finalize_server_handshake(State) ->
-    ConnectionStates0 = cipher_protocol(State),
-    ConnectionStates = 
-        ssl_record:activate_pending_connection_state(ConnectionStates0, 
-						     write),
-    finished(State#state{connection_states = ConnectionStates}).
-
-cipher_protocol(#state{connection_states = ConnectionStates,
+cipher_protocol(#state{connection_states = ConnectionStates0,
                        socket = Socket,
                        negotiated_version = Version,
                        transport_cb = Transport}) ->
-    {BinChangeCipher, NewConnectionStates} =
+    {BinChangeCipher, ConnectionStates} =
         encode_change_cipher(#change_cipher_spec{}, 
-			     Version, ConnectionStates),
+			     Version, ConnectionStates0),
     Transport:send(Socket, BinChangeCipher),
-    NewConnectionStates.
+    ConnectionStates.
    
 finished(#state{role = Role, socket = Socket, negotiated_version = Version,
                 transport_cb = Transport,
 		session = Session,
-                connection_states = ConnectionStates,
-                tls_handshake_hashes = Hashes}) ->
+                connection_states = ConnectionStates0,
+                tls_handshake_hashes = Hashes0}, StateName) ->
     MasterSecret = Session#session.master_secret,
-    Finished = ssl_handshake:finished(Version, Role, MasterSecret, Hashes),
-    {BinFinished, NewConnectionStates, NewHashes} = 
-        encode_handshake(Finished, Version, ConnectionStates, Hashes),
+    Finished = ssl_handshake:finished(Version, Role, MasterSecret, Hashes0),
+    ConnectionStates1 = save_verify_data(Role, Finished, ConnectionStates0, StateName),
+    {BinFinished, ConnectionStates, Hashes} = 
+        encode_handshake(Finished, Version, ConnectionStates1, Hashes0),
     Transport:send(Socket, BinFinished),
-    {NewConnectionStates, NewHashes}.
+    {ConnectionStates, Hashes}.
+
+save_verify_data(client, #finished{verify_data = Data}, ConnectionStates, certify) ->
+    ssl_record:set_client_verify_data(current_write, Data, ConnectionStates);
+save_verify_data(server, #finished{verify_data = Data}, ConnectionStates, cipher) ->
+    ssl_record:set_server_verify_data(current_both, Data, ConnectionStates);
+save_verify_data(client, #finished{verify_data = Data}, ConnectionStates, abbreviated) ->
+    ssl_record:set_client_verify_data(current_both, Data, ConnectionStates);
+save_verify_data(server, #finished{verify_data = Data}, ConnectionStates, abbreviated) ->
+    ssl_record:set_server_verify_data(current_write, Data, ConnectionStates).
 
 handle_server_key(
   #server_key_exchange{params = 
@@ -1710,20 +1742,13 @@ format_packet_error(#socket_options{active = false, mode = Mode}, Data) ->
 format_packet_error(#socket_options{active = _, mode = Mode}, Data) ->
     {ssl_error, sslsocket(), {invalid_packet, format_reply(Mode, raw, 0, Data)}}.
 
-format_reply(_, http, _,Data) ->  Data;
-format_reply(_, http_bin, _, Data) ->  Data;
-format_reply(_, {http, headers}, _,Data) ->  Data;
-format_reply(_, {http_bin, headers}, _, Data) ->  Data;
-format_reply(_, asn1, _,Data) ->  Data;
-format_reply(_, cdr, _, Data) ->  Data;
-format_reply(_, sunrm, _,Data) ->  Data;
-format_reply(_, fcgi, _, Data) ->  Data;
-format_reply(_, tpkt, _, Data) ->  Data;
-format_reply(_, line, _, Data) ->  Data;
 format_reply(binary, _, N, Data) when N > 0 ->  % Header mode
     header(N, Data);
 format_reply(binary, _, _, Data) ->  Data;
-format_reply(list, _, _, Data) ->  binary_to_list(Data).
+format_reply(list, Packet, _, Data) when is_integer(Packet); Packet == raw -> 
+    binary_to_list(Data);
+format_reply(list, _,_, Data) ->
+    Data.
 
 header(0, <<>>) ->
     <<>>;
@@ -1781,7 +1806,7 @@ next_state(StateName, #ssl_tls{type = ?HANDSHAKE, fragment = Data},
    		Hs1 = ssl_handshake:update_hashes(Hs0, Raw),
    		?MODULE:SName(Packet, State#state{tls_handshake_hashes=Hs1,
    						  renegotiation = {true, peer}});
- 	   ({Packet, Raw}, {next_state, SName, State = #state{tls_handshake_hashes=Hs0}}) ->	
+ 	   ({Packet, Raw}, {next_state, SName, State = #state{tls_handshake_hashes=Hs0}}) ->
    		Hs1 = ssl_handshake:update_hashes(Hs0, Raw),
    		?MODULE:SName(Packet, State#state{tls_handshake_hashes=Hs1});
    	   (_, StopState) -> StopState
@@ -1802,7 +1827,6 @@ next_state(StateName, #ssl_tls{type = ?APPLICATION_DATA, fragment = Data}, State
 	 {Record, State} ->
    	    next_state(StateName, Record, State)
     end;
-
 next_state(StateName, #ssl_tls{type = ?CHANGE_CIPHER_SPEC, fragment = <<1>>} = 
  	   _ChangeCipher, 
  	   #state{connection_states = ConnectionStates0} = State0) ->
@@ -1816,6 +1840,17 @@ next_state(StateName, #ssl_tls{type = _Unknown}, State0) ->
     {Record, State} = next_record(State0),
     next_state(StateName, Record, State).
 
+next_tls_record(Data, #state{tls_record_buffer = Buf0,
+		       tls_cipher_texts = CT0} = State0) ->
+    case ssl_record:get_tls_records(Data, Buf0) of
+	{Records, Buf1} ->
+	    CT1 = CT0 ++ Records,
+	    next_record(State0#state{tls_record_buffer = Buf1,
+				     tls_cipher_texts = CT1});
+	#alert{} = Alert ->
+	    Alert
+    end.
+
 next_record(#state{tls_cipher_texts = [], socket = Socket} = State) ->
     inet:setopts(Socket, [{active,once}]),
     {no_record, State};
@@ -1892,7 +1927,7 @@ invalidate_session(server, _, Port, Session) ->
     ssl_manager:invalidate_session(Port, Session).
 
 initial_state(Role, Host, Port, Socket, {SSLOptions, SocketOptions}, User,
-	      {CbModule, DataTag, CloseTag}) ->
+	      {CbModule, DataTag, CloseTag, ErrorTag}) ->
     ConnectionStates = ssl_record:init_connection_states(Role),
     
     SessionCacheCb = case application:get_env(ssl, session_cb) of
@@ -1912,6 +1947,7 @@ initial_state(Role, Host, Port, Socket, {SSLOptions, SocketOptions}, User,
 	   transport_cb = CbModule,
 	   data_tag = DataTag,
 	   close_tag = CloseTag,
+	   error_tag = ErrorTag,
 	   role = Role,
 	   host = Host,
 	   port = Port,
@@ -2076,12 +2112,6 @@ handle_own_alert(Alert, Version, StateName,
     try %% Try to tell the other side
 	{BinMsg, _} =
 	encode_alert(Alert, Version, ConnectionStates),
-	%% Try to make sure alert will be sent before socket is closed
-	%% when process ends. This will help on some
-	%% linux platforms and knowingly not break anything on other 
-	%% platforms. Other platforms will benefit from shutdown that is now
-	%% done before close.
-	inet:setopts(Socket, [{nodelay, true}]),
 	Transport:send(Socket, BinMsg)
     catch _:_ ->  %% Can crash if we are in a uninitialized state
 	    ignore
@@ -2155,3 +2185,8 @@ notify_renegotiater({true, From}) when not is_atom(From)  ->
     gen_fsm:reply(From, {error, closed});
 notify_renegotiater(_) ->
     ok.
+
+workaround_transport_delivery_problems(Socket, Transport) ->
+    inet:setopts(Socket, [{active, false}]),
+    Transport:shutdown(Socket, write),
+    Transport:recv(Socket, 0).
diff --git a/lib/ssl/src/ssl_handshake.erl b/lib/ssl/src/ssl_handshake.erl
index 9f5ac7106a..f0413c4d31 100644
--- a/lib/ssl/src/ssl_handshake.erl
+++ b/lib/ssl/src/ssl_handshake.erl
@@ -31,7 +31,7 @@
 -include("ssl_debug.hrl").
 -include_lib("public_key/include/public_key.hrl").
 
--export([master_secret/4, client_hello/4, server_hello/3, hello/2,
+-export([master_secret/4, client_hello/5, server_hello/4, hello/4,
 	 hello_request/0, certify/7, certificate/3, 
 	 client_certificate_verify/6, 
 	 certificate_verify/6, certificate_request/2,
@@ -57,7 +57,7 @@
 %%--------------------------------------------------------------------
 client_hello(Host, Port, ConnectionStates, #ssl_options{versions = Versions,
 							ciphers = Ciphers} 
-	     = SslOpts) ->
+	     = SslOpts, Renegotiation) ->
     
     Fun = fun(Version) ->
 		  ssl_record:protocol_version(Version)
@@ -70,22 +70,25 @@ client_hello(Host, Port, ConnectionStates, #ssl_options{versions = Versions,
 
     #client_hello{session_id = Id, 
 		  client_version = Version,
-		  cipher_suites = Ciphers,
+		  cipher_suites = cipher_suites(Ciphers, Renegotiation),
 		  compression_methods = ssl_record:compressions(),
-		  random = SecParams#security_parameters.client_random
+		  random = SecParams#security_parameters.client_random,
+		  renegotiation_info  = 
+		  renegotiation_info(client, ConnectionStates, Renegotiation)
 		 }.
 
 %%--------------------------------------------------------------------
-%% Function: server_hello(Host, Port, SessionId, 
-%%                        Version, ConnectionStates) -> #server_hello{} 
+%% Function: server_hello(SessionId, Version, 
+%%                        ConnectionStates, Renegotiation) -> #server_hello{} 
 %%      SessionId
 %%      Version
-%%      ConnectionStates 
+%%      ConnectionStates
+%%      Renegotiation 
 %%	
 %%
 %% Description: Creates a server hello message.
 %%--------------------------------------------------------------------
-server_hello(SessionId, Version, ConnectionStates) ->
+server_hello(SessionId, Version, ConnectionStates, Renegotiation) ->
     Pending = ssl_record:pending_connection_state(ConnectionStates, read),
     SecParams = Pending#connection_state.security_parameters,
     #server_hello{server_version = Version,
@@ -93,7 +96,9 @@ server_hello(SessionId, Version, ConnectionStates) ->
                   compression_method = 
 		  SecParams#security_parameters.compression_algorithm,
 		  random = SecParams#security_parameters.server_random,
-		  session_id = SessionId
+		  session_id = SessionId,
+		  renegotiation_info = 
+		  renegotiation_info(server, ConnectionStates, Renegotiation)
 		 }.
 
 %%--------------------------------------------------------------------
@@ -106,27 +111,41 @@ hello_request() ->
     #hello_request{}.
 
 %%--------------------------------------------------------------------
-%% Function: hello(Hello, Info) -> 
+%% Function: hello(Hello, Info, Renegotiation) -> 
 %%                                   {Version, Id, NewConnectionStates} |
 %%                                   #alert{}
 %%
 %%      Hello = #client_hello{} | #server_hello{}
-%%      Info = ConnectionStates | {Port, Session, ConnectionStates}
+%%      Info = ConnectionStates | {Port, #ssl_options{}, Session, 
+%%                                 Cahce, CahceCb, ConnectionStates}
 %%      ConnectionStates = #connection_states{}
+%%      Renegotiation = boolean()
 %%
 %% Description: Handles a recieved hello message
 %%--------------------------------------------------------------------
 hello(#server_hello{cipher_suite = CipherSuite, server_version = Version,
 		    compression_method = Compression, random = Random,
-		    session_id = SessionId}, ConnectionStates) ->
-    NewConnectionStates =
-	hello_pending_connection_states(client, CipherSuite, Random, 
-					Compression, ConnectionStates),
-    {Version, SessionId, NewConnectionStates};
-
-hello(#client_hello{client_version = ClientVersion, random = Random} = Hello,
-      {Port, #ssl_options{versions = Versions} = SslOpts,
-       Session0, Cache, CacheCb, ConnectionStates0}) ->
+		    session_id = SessionId, renegotiation_info = Info},
+      #ssl_options{secure_renegotiate = SecureRenegotation},
+      ConnectionStates0, Renegotiation) ->
+    
+    case handle_renegotiation_info(client, Info, ConnectionStates0, 
+				   Renegotiation, SecureRenegotation, []) of
+	{ok, ConnectionStates1} ->
+	    ConnectionStates =
+		hello_pending_connection_states(client, CipherSuite, Random, 
+						Compression, ConnectionStates1),
+	    {Version, SessionId, ConnectionStates};
+	#alert{} = Alert ->
+	    Alert
+    end;
+			       
+hello(#client_hello{client_version = ClientVersion, random = Random,
+		    cipher_suites = CipherSuites,
+		    renegotiation_info = Info} = Hello,
+      #ssl_options{versions = Versions, 
+		   secure_renegotiate = SecureRenegotation} = SslOpts,
+      {Port, Session0, Cache, CacheCb, ConnectionStates0}, Renegotiation) ->
     Version = select_version(ClientVersion, Versions),
     case ssl_record:is_acceptable_version(Version) of
 	true ->
@@ -138,13 +157,20 @@ hello(#client_hello{client_version = ClientVersion, random = Random} = Hello,
 		no_suite ->
 		    ?ALERT_REC(?FATAL, ?INSUFFICIENT_SECURITY);
 		_ ->
-		    ConnectionStates =
-			hello_pending_connection_states(server, 
-							CipherSuite,
-						        Random, 
-							Compression,
-							ConnectionStates0),
-		    {Version, {Type, Session}, ConnectionStates}
+		    case handle_renegotiation_info(server, Info, ConnectionStates0,
+						   Renegotiation, SecureRenegotation, 
+						   CipherSuites) of
+			{ok, ConnectionStates1} ->
+			    ConnectionStates =
+				hello_pending_connection_states(server, 
+								CipherSuite,
+								Random, 
+								Compression,
+								ConnectionStates1),
+			    {Version, {Type, Session}, ConnectionStates};
+			#alert{} = Alert ->
+			    Alert
+		    end
 	    end;
 	false ->
 	    ?ALERT_REC(?FATAL, ?PROTOCOL_VERSION)
@@ -525,7 +551,109 @@ select_session(Hello, Port, Session, Version,
 	false ->	    
 	    {resumed, CacheCb:lookup(Cache, {Port, SessionId})}
     end.
-	    
+
+
+cipher_suites(Suites, false) ->
+    [?TLS_EMPTY_RENEGOTIATION_INFO_SCSV | Suites];
+cipher_suites(Suites, true) ->
+    Suites.
+
+renegotiation_info(client, _, false) ->
+    #renegotiation_info{renegotiated_connection = undefined};
+renegotiation_info(server, ConnectionStates, false) ->
+    CS  = ssl_record:current_connection_state(ConnectionStates, read),
+    case CS#connection_state.secure_renegotiation of
+	true ->
+	    #renegotiation_info{renegotiated_connection = ?byte(0)};
+	false ->
+	    #renegotiation_info{renegotiated_connection = undefined}
+    end;
+renegotiation_info(client, ConnectionStates, true) ->
+    CS = ssl_record:current_connection_state(ConnectionStates, read),
+    case CS#connection_state.secure_renegotiation of
+	true ->
+	    Data = CS#connection_state.client_verify_data,
+	    #renegotiation_info{renegotiated_connection = Data};
+	false ->
+	    #renegotiation_info{renegotiated_connection = undefined}
+    end;
+
+renegotiation_info(server, ConnectionStates, true) ->
+    CS = ssl_record:current_connection_state(ConnectionStates, read),
+    case CS#connection_state.secure_renegotiation of
+	true ->
+	    CData = CS#connection_state.client_verify_data,
+	    SData  =CS#connection_state.server_verify_data,
+	    #renegotiation_info{renegotiated_connection = <<CData/binary, SData/binary>>};
+	false ->
+	    #renegotiation_info{renegotiated_connection = undefined}
+    end. 
+
+handle_renegotiation_info(_, #renegotiation_info{renegotiated_connection = ?byte(0)}, 
+			  ConnectionStates, false, _, _) ->
+    {ok, ssl_record:set_renegotiation_flag(true, ConnectionStates)};
+
+handle_renegotiation_info(server, undefined, ConnectionStates, _, _, CipherSuites) -> 
+    case is_member(?TLS_EMPTY_RENEGOTIATION_INFO_SCSV, CipherSuites) of
+	true ->
+	    {ok, ssl_record:set_renegotiation_flag(true, ConnectionStates)};
+	false ->
+	    {ok, ssl_record:set_renegotiation_flag(false, ConnectionStates)}
+    end;
+
+handle_renegotiation_info(_, undefined, ConnectionStates, false, _, _) ->
+    {ok, ssl_record:set_renegotiation_flag(false, ConnectionStates)};
+
+handle_renegotiation_info(client, #renegotiation_info{renegotiated_connection = ClientServerVerify}, 
+			  ConnectionStates, true, _, _) ->
+    CS = ssl_record:current_connection_state(ConnectionStates, read),
+    CData = CS#connection_state.client_verify_data,
+    SData = CS#connection_state.server_verify_data,    
+    case <<CData/binary, SData/binary>> == ClientServerVerify of
+	true ->
+	    {ok, ConnectionStates};
+	false ->
+	    ?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE)
+    end;
+handle_renegotiation_info(server, #renegotiation_info{renegotiated_connection = ClientVerify}, 
+			  ConnectionStates, true, _, CipherSuites) ->
+    
+      case is_member(?TLS_EMPTY_RENEGOTIATION_INFO_SCSV, CipherSuites) of
+	  true ->
+	      ?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE);
+	  false ->	
+	      CS = ssl_record:current_connection_state(ConnectionStates, read),
+	      Data = CS#connection_state.client_verify_data,
+	      case Data == ClientVerify of
+		  true ->
+		      {ok, ConnectionStates};
+		  false ->
+		      ?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE)
+	      end
+      end;
+
+handle_renegotiation_info(client, undefined, ConnectionStates, true, SecureRenegotation, _) ->
+    handle_renegotiation_info(ConnectionStates, SecureRenegotation);
+
+handle_renegotiation_info(server, undefined, ConnectionStates, true, SecureRenegotation, CipherSuites) ->
+     case is_member(?TLS_EMPTY_RENEGOTIATION_INFO_SCSV, CipherSuites) of
+	  true ->
+	     ?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE);
+	 false ->
+	     handle_renegotiation_info(ConnectionStates, SecureRenegotation)
+     end.
+
+handle_renegotiation_info(ConnectionStates, SecureRenegotation) ->
+    CS = ssl_record:current_connection_state(ConnectionStates, read),
+    case {SecureRenegotation, CS#connection_state.secure_renegotiation} of
+	{_, true} ->
+	    ?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE);
+	{true, false} ->
+	    ?ALERT_REC(?FATAL, ?NO_RENEGOTIATION);
+	{false, false} ->
+	    {ok, ConnectionStates}
+    end.
+
 %% Update pending connection states with parameters exchanged via 
 %% hello messages
 %% NOTE : Role is the role of the receiver of the hello message
@@ -636,31 +764,52 @@ dec_hs(?CLIENT_HELLO, <<?BYTE(Major), ?BYTE(Minor),
 		  random = ssl_ssl2:client_random(ChallengeData, CDLength),
 		  session_id = 0,
 		  cipher_suites = from_3bytes(CipherSuites),
-		  compression_methods = [?NULL]
+		  compression_methods = [?NULL],
+		  renegotiation_info = undefined
 		 };
 dec_hs(?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,
-		       _FutureCompatData/binary>>,
+		       Extensions/binary>>,
        _, _) ->
+    
+    RenegotiationInfo = proplists:get_value(renegotiation_info, dec_hello_extensions(Extensions),
+					   undefined),    
     #client_hello{
 	client_version = {Major,Minor},
 	random = Random,
 	session_id = Session_ID,
 	cipher_suites = from_2bytes(CipherSuites),
-	compression_methods = Comp_methods
+	compression_methods = Comp_methods,
+	renegotiation_info = RenegotiationInfo 
        };
+
 dec_hs(?SERVER_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
 		       ?BYTE(SID_length), Session_ID:SID_length/binary,
-		       Cipher_suite:2/binary, ?BYTE(Comp_method)>>, _, _) ->
+		       Cipher_suite:2/binary, ?BYTE(Comp_method)>>, _, _) ->    
     #server_hello{
 	server_version = {Major,Minor},
 	random = Random,
 	session_id = Session_ID,
 	cipher_suite = Cipher_suite,
-	compression_method = Comp_method
-       };
+	compression_method = Comp_method,
+	renegotiation_info = undefined};
+
+dec_hs(?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>>, _, _) ->
+    
+    RenegotiationInfo = proplists:get_value(renegotiation_info, dec_hello_extensions(Extensions, []),
+					   undefined),   
+    #server_hello{
+	server_version = {Major,Minor},
+	random = Random,
+	session_id = Session_ID,
+	cipher_suite = Cipher_suite,
+	compression_method = Comp_method,
+	renegotiation_info = RenegotiationInfo};
 dec_hs(?CERTIFICATE, <<?UINT24(ACLen), ASN1Certs:ACLen/binary>>, _, _) ->
     #certificate{asn1_certificates = certs_to_list(ASN1Certs)};
 dec_hs(?SERVER_KEY_EXCHANGE, <<?UINT16(ModLen), Mod:ModLen/binary,
@@ -707,6 +856,32 @@ dec_hs(?FINISHED, VerifyData, _, _) ->
 dec_hs(_, _, _, _) ->
     throw(?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE)).
 
+dec_hello_extensions(<<>>) ->
+    [];
+dec_hello_extensions(<<?UINT16(ExtLen), Extensions:ExtLen/binary>>) ->
+    dec_hello_extensions(Extensions, []);
+dec_hello_extensions(_) ->
+    [].
+
+dec_hello_extensions(<<>>, Acc) ->
+    Acc;
+dec_hello_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
+			  _ ->
+			      VerifyLen = Len - 1,
+			      <<?BYTE(VerifyLen), VerifyInfo/binary>> = Info,
+			      VerifyInfo
+		      end,	    
+    dec_hello_extensions(Rest, [{renegotiation_info, 
+			   #renegotiation_info{renegotiated_connection = RenegotiateInfo}} | Acc]);
+dec_hello_extensions(<<?UINT16(_), ?UINT16(Len), _Unknown:Len, Rest/binary>>, Acc) ->
+    dec_hello_extensions(Rest, Acc);
+%% Need this clause?
+dec_hello_extensions(_, Acc) ->
+    Acc.
+
 encrypted_premaster_secret(Secret, RSAPublicKey) -> 
     try 
 	PreMasterSecret = public_key:encrypt_public(Secret, RSAPublicKey, 
@@ -743,31 +918,36 @@ certs_from_list(ACList) ->
 
 enc_hs(#hello_request{}, _Version, _) ->
     {?HELLO_REQUEST, <<>>};
-enc_hs(#client_hello{
-	client_version = {Major, Minor},
-	random = Random,
-	session_id = SessionID,
-	cipher_suites = CipherSuites,
-	compression_methods = CompMethods}, _Version, _) ->
+enc_hs(#client_hello{client_version = {Major, Minor},
+		     random = Random,
+		     session_id = SessionID,
+		     cipher_suites = CipherSuites,
+		     compression_methods = CompMethods, 
+		     renegotiation_info = RenegotiationInfo}, _Version, _) ->
     SIDLength = byte_size(SessionID),
     BinCompMethods = list_to_binary(CompMethods),
     CmLength = byte_size(BinCompMethods),
     BinCipherSuites = list_to_binary(CipherSuites),
     CsLength = byte_size(BinCipherSuites),
+    Extensions  = hello_extensions(RenegotiationInfo),
+    ExtensionsBin = enc_hello_extensions(Extensions),
     {?CLIENT_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
 		     ?BYTE(SIDLength), SessionID/binary,
 		     ?UINT16(CsLength), BinCipherSuites/binary,
-		     ?BYTE(CmLength), BinCompMethods/binary>>};
-enc_hs(#server_hello{
-	server_version = {Major, Minor},
-	random = Random,
-	session_id = Session_ID,
-	cipher_suite = Cipher_suite,
-	compression_method = Comp_method}, _Version, _) ->
+		     ?BYTE(CmLength), BinCompMethods/binary, ExtensionsBin/binary>>};
+
+enc_hs(#server_hello{server_version = {Major, Minor},
+		     random = Random,
+		     session_id = Session_ID,
+		     cipher_suite = Cipher_suite,
+		     compression_method = Comp_method,
+		     renegotiation_info = RenegotiationInfo}, _Version, _) ->
     SID_length = byte_size(Session_ID),
+    Extensions  = hello_extensions(RenegotiationInfo),
+    ExtensionsBin = enc_hello_extensions(Extensions),
     {?SERVER_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
 		     ?BYTE(SID_length), Session_ID/binary,
-                     Cipher_suite/binary, ?BYTE(Comp_method)>>};
+                     Cipher_suite/binary, ?BYTE(Comp_method), ExtensionsBin/binary>>};
 enc_hs(#certificate{asn1_certificates = ASN1CertList}, _Version, _) ->
     ASN1Certs = certs_from_list(ASN1CertList),
     ACLen = erlang:iolist_size(ASN1Certs),
@@ -826,6 +1006,29 @@ enc_bin_sig(BinSig) ->
     Size = byte_size(BinSig),
     <<?UINT16(Size), BinSig/binary>>.
 
+%% Renegotiation info, only current extension
+hello_extensions(#renegotiation_info{renegotiated_connection = undefined}) ->
+    [];
+hello_extensions(#renegotiation_info{} = Info) ->
+    [Info].
+
+enc_hello_extensions(Extensions) ->
+    enc_hello_extensions(Extensions, <<>>).
+enc_hello_extensions([], <<>>) ->
+    <<>>;
+enc_hello_extensions([], Acc) ->
+    Size = byte_size(Acc),
+    <<?UINT16(Size), Acc/binary>>;
+
+enc_hello_extensions([#renegotiation_info{renegotiated_connection = ?byte(0) = Info} | Rest], Acc) ->
+    Len = byte_size(Info),
+    enc_hello_extensions(Rest, <<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), Info/binary, Acc/binary>>);
+
+enc_hello_extensions([#renegotiation_info{renegotiated_connection = Info} | Rest], Acc) ->
+    InfoLen = byte_size(Info),
+    Len = InfoLen +1,
+    enc_hello_extensions(Rest, <<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), ?BYTE(InfoLen), Info/binary, Acc/binary>>).
+
 init_hashes() ->
     T = {crypto:md5_init(), crypto:sha_init()},
     {T, T}.
diff --git a/lib/ssl/src/ssl_handshake.hrl b/lib/ssl/src/ssl_handshake.hrl
index 889d39f2af..74fba3786c 100644
--- a/lib/ssl/src/ssl_handshake.hrl
+++ b/lib/ssl/src/ssl_handshake.hrl
@@ -81,7 +81,8 @@
 	  random,             
 	  session_id,         % opaque SessionID<0..32>
 	  cipher_suites,      % cipher_suites<2..2^16-1>
-	  compression_methods % compression_methods<1..2^8-1>
+	  compression_methods, % compression_methods<1..2^8-1>,
+	  renegotiation_info
 	 }).
 
 -record(server_hello, {
@@ -89,7 +90,8 @@
 	  random,             
 	  session_id,         % opaque SessionID<0..32>
 	  cipher_suite,       % cipher_suites
-	  compression_method  % compression_method
+	  compression_method, % compression_method
+	  renegotiation_info
 	 }).
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -195,6 +197,15 @@
 	  verify_data %opaque verify_data[12]
 	 }).
 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Renegotiation info  RFC 5746 section 3.2
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-define(RENEGOTIATION_EXT, 16#ff01).
+
+-record(renegotiation_info,{
+	  renegotiated_connection
+	 }).
+
 -endif. % -ifdef(ssl_handshake).
 
 
diff --git a/lib/ssl/src/ssl_internal.hrl b/lib/ssl/src/ssl_internal.hrl
index 8d19abfe1e..fdc0c33750 100644
--- a/lib/ssl/src/ssl_internal.hrl
+++ b/lib/ssl/src/ssl_internal.hrl
@@ -75,6 +75,7 @@
 	  %% will be reused if possible.
 	  reuse_sessions, % boolean()
 	  renegotiate_at,
+	  secure_renegotiate,
 	  debug           %
 	  }).
 
diff --git a/lib/ssl/src/ssl_record.erl b/lib/ssl/src/ssl_record.erl
index da48f049f6..f9f915f13d 100644
--- a/lib/ssl/src/ssl_record.erl
+++ b/lib/ssl/src/ssl_record.erl
@@ -38,7 +38,10 @@
          set_mac_secret/4,
 	 set_master_secret/2, 
          activate_pending_connection_state/2,
-         set_pending_cipher_state/4]).
+         set_pending_cipher_state/4,
+	 set_renegotiation_flag/2,
+	 set_client_verify_data/3,
+	 set_server_verify_data/3]).
 
 %% Handling of incoming data
 -export([get_tls_records/2]).
@@ -175,6 +178,98 @@ set_master_secret(MasterSecret,
                                        master_secret = MasterSecret}},
     States#connection_states{pending_read = Read1, pending_write = Write1}.
 
+%%--------------------------------------------------------------------
+%% Function: set_renegotiation_flag(Flag, States) -> 
+%%                                                #connection_states{}
+%%      Flag = boolean()
+%%	States = #connection_states{}
+%%
+%% Set master_secret in pending connection states
+%%--------------------------------------------------------------------
+set_renegotiation_flag(Flag, #connection_states{
+			 current_read = CurrentRead0,
+			 current_write = CurrentWrite0,
+			 pending_read = PendingRead0,
+			 pending_write = PendingWrite0} 
+		       = ConnectionStates) ->
+    CurrentRead = CurrentRead0#connection_state{secure_renegotiation = Flag},
+    CurrentWrite = CurrentWrite0#connection_state{secure_renegotiation = Flag},
+    PendingRead = PendingRead0#connection_state{secure_renegotiation = Flag},
+    PendingWrite = PendingWrite0#connection_state{secure_renegotiation = Flag},
+    ConnectionStates#connection_states{current_read = CurrentRead, 
+				       current_write = CurrentWrite, 
+				       pending_read = PendingRead, 
+				       pending_write = PendingWrite}.
+
+%%--------------------------------------------------------------------
+%% Function: set_client_verify_data(State, Data, States) -> 
+%%                                                #connection_states{}
+%%      State = atom()
+%%      Data = binary()
+%%	States = #connection_states{}
+%%
+%% Set verify data in connection states.                 
+%%--------------------------------------------------------------------
+set_client_verify_data(current_read, Data, 
+		       #connection_states{current_read = CurrentRead0,
+					  pending_write = PendingWrite0} 
+		       = ConnectionStates) ->
+    CurrentRead = CurrentRead0#connection_state{client_verify_data = Data},
+    PendingWrite = PendingWrite0#connection_state{client_verify_data = Data},
+    ConnectionStates#connection_states{current_read = CurrentRead,
+				       pending_write = PendingWrite};
+set_client_verify_data(current_write, Data, 
+		       #connection_states{pending_read = PendingRead0,
+					  current_write = CurrentWrite0} 
+		       = ConnectionStates) ->
+    PendingRead = PendingRead0#connection_state{client_verify_data = Data},
+    CurrentWrite = CurrentWrite0#connection_state{client_verify_data = Data},
+    ConnectionStates#connection_states{pending_read = PendingRead,
+				       current_write = CurrentWrite};
+set_client_verify_data(current_both, Data, 
+		       #connection_states{current_read = CurrentRead0,
+					  current_write = CurrentWrite0} 
+		       = ConnectionStates) ->
+    CurrentRead = CurrentRead0#connection_state{client_verify_data = Data},
+    CurrentWrite = CurrentWrite0#connection_state{client_verify_data = Data},
+    ConnectionStates#connection_states{current_read = CurrentRead,
+				       current_write = CurrentWrite}.
+
+%%--------------------------------------------------------------------
+%% Function: set_server_verify_data(State, Data, States) -> 
+%%                                                #connection_states{}
+%%      State = atom()
+%%      Data = binary()
+%%	States = #connection_states{}
+%%
+%% Set verify data in pending connection states.
+%%--------------------------------------------------------------------
+set_server_verify_data(current_write, Data, 
+		       #connection_states{pending_read = PendingRead0,
+					  current_write = CurrentWrite0} 
+		       = ConnectionStates) ->
+    PendingRead = PendingRead0#connection_state{server_verify_data = Data},
+    CurrentWrite = CurrentWrite0#connection_state{server_verify_data = Data},
+    ConnectionStates#connection_states{pending_read = PendingRead,
+				       current_write = CurrentWrite};
+
+set_server_verify_data(current_read, Data, 
+		       #connection_states{current_read = CurrentRead0,
+					  pending_write = PendingWrite0} 
+		       = ConnectionStates) ->
+    CurrentRead = CurrentRead0#connection_state{server_verify_data = Data},
+    PendingWrite = PendingWrite0#connection_state{server_verify_data = Data},
+    ConnectionStates#connection_states{current_read = CurrentRead,
+				       pending_write = PendingWrite};
+
+set_server_verify_data(current_both, Data, 
+		       #connection_states{current_read = CurrentRead0,
+					  current_write = CurrentWrite0} 
+		       = ConnectionStates) ->
+    CurrentRead = CurrentRead0#connection_state{server_verify_data = Data},
+    CurrentWrite = CurrentWrite0#connection_state{server_verify_data = Data},
+    ConnectionStates#connection_states{current_read = CurrentRead,
+				       current_write = CurrentWrite}.
 
 %%--------------------------------------------------------------------
 %% Function: activate_pending_connection_state(States, Type) -> 
@@ -191,7 +286,9 @@ activate_pending_connection_state(States =
     NewCurrent = Pending#connection_state{sequence_number = 0},
     SecParams = Pending#connection_state.security_parameters,
     ConnectionEnd = SecParams#security_parameters.connection_end,
-    NewPending = empty_connection_state(ConnectionEnd),
+    EmptyPending = empty_connection_state(ConnectionEnd),
+    SecureRenegotation = NewCurrent#connection_state.secure_renegotiation,
+    NewPending = EmptyPending#connection_state{secure_renegotiation = SecureRenegotation},
     States#connection_states{current_read = NewCurrent,
                              pending_read = NewPending
                             };
@@ -202,7 +299,9 @@ activate_pending_connection_state(States =
     NewCurrent = Pending#connection_state{sequence_number = 0},
     SecParams = Pending#connection_state.security_parameters,
     ConnectionEnd = SecParams#security_parameters.connection_end,
-    NewPending = empty_connection_state(ConnectionEnd),
+    EmptyPending = empty_connection_state(ConnectionEnd),
+    SecureRenegotation = NewCurrent#connection_state.secure_renegotiation,
+    NewPending = EmptyPending#connection_state{secure_renegotiation = SecureRenegotation},
     States#connection_states{current_write = NewCurrent,
                              pending_write = NewPending
                             }.
diff --git a/lib/ssl/src/ssl_record.hrl b/lib/ssl/src/ssl_record.hrl
index 362b7039d4..5fb0070b91 100644
--- a/lib/ssl/src/ssl_record.hrl
+++ b/lib/ssl/src/ssl_record.hrl
@@ -60,7 +60,11 @@
 	  compression_state,
 	  cipher_state,
 	  mac_secret,
-	  sequence_number
+	  sequence_number,
+	  %% RFC 5746
+	  secure_renegotiation,
+	  client_verify_data,
+	  server_verify_data
 	 }).
 
 -define(MAX_SEQENCE_NUMBER, 18446744073709552000). %% math:pow(2, 64) - 1 = 1.8446744073709552e19