Refreshed documentation to reflect the change of default implementation.

Started to improve code documentation by using -spec directive, and
some small refactorings to avoid ugly code.

7 files changed, 233 insertions, 235 deletions

diff --git a/lib/ssl/src/ssl_connection.erl b/lib/ssl/src/ssl_connection.erl
index 07fa101ed4..12de624e78 100644
--- a/lib/ssl/src/ssl_connection.erl
+++ b/lib/ssl/src/ssl_connection.erl
@@ -98,12 +98,17 @@
 	#'DHParameter'{prime = ?DEFAULT_DIFFIE_HELLMAN_PRIME, 
 		       base = ?DEFAULT_DIFFIE_HELLMAN_GENERATOR}).
 
+-type state_name()           :: hello | abbreviated | certify | cipher | connection.
+-type gen_fsm_state_return() :: {next_state, state_name(), #state{}} |
+{next_state, state_name(), #state{}, timeout()} |
+{stop, term(), #state{}}.
+
 %%====================================================================
 %% Internal application API
 %%====================================================================	     
 
 %%--------------------------------------------------------------------
-%% Function: send(Pid, Data) ->  ok | {error, Reason} 
+-spec send(pid(), iolist()) -> ok | {error, reason()}.
 %%
 %% Description: Sends data over the ssl connection
 %%--------------------------------------------------------------------
@@ -112,15 +117,16 @@ send(Pid, Data) ->
 				    erlang:iolist_to_binary(Data)}, infinity).
 
 %%--------------------------------------------------------------------
-%% Function:  recv(Socket, Length Timeout) -> {ok, Data} | {error, reason}
+-spec recv(pid(), integer(), timeout()) ->  
+    {ok, binary() | list()} | {error, reason()}.
 %%
 %% Description:  Receives data when active = false
 %%--------------------------------------------------------------------
 recv(Pid, Length, Timeout) -> 
     sync_send_all_state_event(Pid, {recv, Length}, Timeout).
 %%--------------------------------------------------------------------
-%% Function: : connect(Host, Port, Socket, Options, 
-%%                     User, CbInfo, Timeout) -> {ok, Socket}
+-spec connect(host(), port_num(), port(), list(), pid(), tuple(), timeout()) ->
+    {ok, #sslsocket{}} | {error, reason()}.
 %%
 %% Description: Connect to a ssl server.
 %%--------------------------------------------------------------------
@@ -132,8 +138,8 @@ connect(Host, Port, Socket, Options, User, CbInfo, Timeout) ->
 	    {error, ssl_not_started}
     end.
 %%--------------------------------------------------------------------
-%% Function: accept(Port, Socket, Opts, User, 
-%%                  CbInfo, Timeout) -> {ok, Socket} | {error, Reason}
+-spec ssl_accept(port_num(), port(), list(), pid(), tuple(), timeout()) ->
+    {ok, #sslsocket{}} | {error, reason()}.
 %%
 %% Description: Performs accept on a ssl listen socket. e.i. performs
 %%              ssl handshake. 
@@ -147,7 +153,7 @@ ssl_accept(Port, Socket, Opts, User, CbInfo, Timeout) ->
     end.	
 
 %%--------------------------------------------------------------------
-%% Function: handshake(SslSocket, Timeout) -> ok | {error, Reason}
+-spec handshake(#sslsocket{}, timeout()) ->  ok | {error, reason()}.
 %%
 %% Description: Starts ssl handshake. 
 %%--------------------------------------------------------------------
@@ -159,7 +165,8 @@ handshake(#sslsocket{pid = Pid}, Timeout) ->
 	    Error
     end.
 %--------------------------------------------------------------------
-%% Function: socket_control(Pid) -> {ok, SslSocket} | {error, Reason}
+-spec socket_control(port(), pid(), atom()) -> 
+    {ok, #sslsocket{}} | {error, reason()}.  
 %%
 %% Description: Set the ssl process to own the accept socket
 %%--------------------------------------------------------------------	    
@@ -172,7 +179,7 @@ socket_control(Socket, Pid, CbModule) ->
     end.
 
 %%--------------------------------------------------------------------
-%% Function:  close() -> ok 
+-spec close(pid()) -> ok | {error, reason()}.  
 %%
 %% Description:  Close a ssl connection
 %%--------------------------------------------------------------------
@@ -185,7 +192,7 @@ close(ConnectionPid) ->
     end.
 
 %%--------------------------------------------------------------------
-%% Function:  shutdown(Socket, How) -> ok | {error, Reason}
+-spec shutdown(pid(), atom()) -> ok | {error, reason()}.  
 %%
 %% Description: Same as gen_tcp:shutdown/2
 %%--------------------------------------------------------------------
@@ -193,7 +200,7 @@ shutdown(ConnectionPid, How) ->
     sync_send_all_state_event(ConnectionPid, {shutdown, How}).
 
 %%--------------------------------------------------------------------
-%% Function: new_user(ConnectionPid, User) -> ok | {error, Reason}
+-spec new_user(pid(), pid()) ->  ok | {error, reason()}.
 %%
 %% Description:  Changes process that receives the messages when active = true
 %% or once. 
@@ -201,28 +208,28 @@ shutdown(ConnectionPid, How) ->
 new_user(ConnectionPid, User) ->
     sync_send_all_state_event(ConnectionPid, {new_user, User}).
 %%--------------------------------------------------------------------
-%% Function: sockname(ConnectionPid) -> {ok, {Address, Port}} | {error, Reason}
+-spec sockname(pid()) -> {ok, {tuple(), port_num()}} | {error, reason()}.
 %%
 %% Description:  Same as inet:sockname/1
 %%--------------------------------------------------------------------
 sockname(ConnectionPid) ->
     sync_send_all_state_event(ConnectionPid, sockname).
 %%--------------------------------------------------------------------
-%% Function: peername(ConnectionPid) -> {ok, {Address, Port}} | {error, Reason}
+-spec peername(pid()) -> {ok, {tuple(), port_num()}} | {error, reason()}.
 %%
 %% Description:  Same as inet:peername/1
 %%--------------------------------------------------------------------
 peername(ConnectionPid) ->
     sync_send_all_state_event(ConnectionPid, peername).
 %%--------------------------------------------------------------------
-%% Function: get_opts(ConnectionPid, OptTags) -> {ok, Options} | {error, Reason}
+-spec get_opts(pid(), list()) -> {ok, list()} | {error, reason()}.    
 %%
 %% Description: Same as inet:getopts/2
 %%--------------------------------------------------------------------
 get_opts(ConnectionPid, OptTags) ->
     sync_send_all_state_event(ConnectionPid, {get_opts, OptTags}).
 %%--------------------------------------------------------------------
-%% Function:  setopts(Socket, Options) -> ok | {error, Reason}
+-spec set_opts(pid(), list()) -> ok | {error, reason()}. 
 %%
 %% Description:  Same as inet:setopts/2
 %%--------------------------------------------------------------------
@@ -230,8 +237,7 @@ set_opts(ConnectionPid, Options) ->
     sync_send_all_state_event(ConnectionPid, {set_opts, Options}).
 
 %%--------------------------------------------------------------------
-%% Function: info(ConnectionPid) ->  {ok, {Protocol, CipherSuite}} | 
-%%                                      {error, Reason}
+-spec info(pid()) ->  {ok, {atom(), tuple()}} | {error, reason()}. 
 %%
 %% Description:  Returns ssl protocol and cipher used for the connection
 %%--------------------------------------------------------------------
@@ -239,7 +245,7 @@ info(ConnectionPid) ->
     sync_send_all_state_event(ConnectionPid, info). 
 
 %%--------------------------------------------------------------------
-%% Function: session_info(ConnectionPid) -> {ok, PropList} | {error, Reason} 
+-spec session_info(pid()) -> {ok, list()} | {error, reason()}. 
 %%
 %% Description:  Returns info about the ssl session
 %%--------------------------------------------------------------------
@@ -247,7 +253,7 @@ session_info(ConnectionPid) ->
     sync_send_all_state_event(ConnectionPid, session_info). 
 
 %%--------------------------------------------------------------------
-%% Function:  peercert(ConnectionPid) -> {ok, Cert} | {error, Reason}
+-spec peer_certificate(pid()) -> {ok, binary()} | {error, reason()}.
 %%
 %% Description: Returns the peer cert
 %%--------------------------------------------------------------------
@@ -255,7 +261,7 @@ peer_certificate(ConnectionPid) ->
     sync_send_all_state_event(ConnectionPid, peer_certificate). 
 
 %%--------------------------------------------------------------------
-%% Function: renegotiation(ConnectionPid) -> ok | {error, Reason}
+-spec renegotiation(pid()) -> ok | {error, reason()}.
 %%
 %% Description: Starts a renegotiation of the ssl session.
 %%--------------------------------------------------------------------
@@ -267,7 +273,8 @@ renegotiation(ConnectionPid) ->
 %%====================================================================
 
 %%--------------------------------------------------------------------
-%% Function: start_link() -> {ok,Pid} | ignore | {error,Error}
+-spec start_link(atom(), host(), port_num(), port(), list(), pid(), tuple()) ->
+    {ok, pid()} | ignore |  {error, reason()}.
 %%
 %% Description: Creates a gen_fsm process which calls Module:init/1 to
 %% initialize. To ensure a synchronized start-up procedure, this function
@@ -281,10 +288,9 @@ start_link(Role, Host, Port, Socket, Options, User, CbInfo) ->
 %% gen_fsm callbacks
 %%====================================================================
 %%--------------------------------------------------------------------
-%% Function: init(Args) -> {ok, StateName, State} |
-%%                         {ok, StateName, State, Timeout} |
-%%                         ignore                              |
-%%                         {stop, StopReason}                   
+-spec init(list()) -> {ok, state_name(), #state{}} 
+			  | {ok, state_name(), #state{}, timeout()} |
+			  ignore | {stop, term()}.                   
 %% Description:Whenever a gen_fsm is started using gen_fsm:start/[3,4] or
 %% gen_fsm:start_link/3,4, this function is called by the new process to 
 %% initialize. 
@@ -309,8 +315,7 @@ init([Role, Host, Port, Socket, {SSLOpts0, _} = Options,
     end.
    
 %%--------------------------------------------------------------------
-%% Function: 
-%% state_name(Event, State) -> {next_state, NextStateName, NextState}|
+%% Function: state_name(Event, State) -> {next_state, NextStateName, NextState}|
 %%                             {next_state, NextStateName, 
 %%                                NextState, Timeout} |
 %%                             {stop, Reason, NewState}
@@ -322,6 +327,9 @@ init([Role, Host, Port, Socket, {SSLOpts0, _} = Options,
 %% the event. It is also called if a timeout occurs.
 %%
 %%--------------------------------------------------------------------
+-spec hello(start | #hello_request{} | #client_hello{} | #server_hello{} | term(),
+	    #state{}) -> gen_fsm_state_return().    
+
 hello(start, #state{host = Host, port = Port, role = client,
 		    ssl_options = SslOpts, 
 		    transport_cb = Transport, socket = Socket,
@@ -359,49 +367,30 @@ hello(#hello_request{}, #state{role = client} = State0) ->
 
 hello(#server_hello{cipher_suite = CipherSuite,
 		    compression_method = Compression} = Hello,
-      #state{session = Session0 = #session{session_id = OldId},
+      #state{session = #session{session_id = OldId},
 	     connection_states = ConnectionStates0,
 	     role = client,
 	     negotiated_version = ReqVersion,
-	     host = Host, port = Port,
 	     renegotiation = {Renegotiation, _},
-	     ssl_options = SslOptions,
-	     session_cache = Cache,
-	     session_cache_cb = CacheCb} = State0) ->
+	     ssl_options = SslOptions} = State0) ->
 
     case ssl_handshake:hello(Hello, SslOptions, ConnectionStates0, Renegotiation) of
-	{Version, NewId, ConnectionStates1} ->
+	{Version, NewId, ConnectionStates} ->
 	    {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},
+	    State = State0#state{key_algorithm = KeyAlgorithm,
+				 negotiated_version = Version,
+				 connection_states = ConnectionStates,
+				 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);
+		    handle_new_session(NewId, CipherSuite, Compression, 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
+		    handle_resumed_session(NewId, State#state{connection_states = ConnectionStates}) 
 	    end;
 	#alert{} = Alert ->
 	    handle_own_alert(Alert, ReqVersion, hello, State0), 
@@ -432,6 +421,9 @@ hello(Hello = #client_hello{client_version = ClientVersion},
 hello(Msg, State) ->
     handle_unexpected_message(Msg, hello, State).
 
+-spec abbreviated(#hello_request{} | #finished{} | term(),
+		  #state{}) -> gen_fsm_state_return().   
+
 abbreviated(#hello_request{}, State0) ->
     {Record, State} = next_record(State0),
     next_state(hello, Record, State);
@@ -477,6 +469,10 @@ abbreviated(#finished{verify_data = Data} = Finished,
 abbreviated(Msg, State) ->
     handle_unexpected_message(Msg, abbreviated, State).
 
+-spec certify(#hello_request{} | #certificate{} |  #server_key_exchange{} |
+	      #certificate_request{} | #server_hello_done{} | #client_key_exchange{} | term(),
+	      #state{}) -> gen_fsm_state_return().   
+
 certify(#hello_request{}, State0) ->
     {Record, State} = next_record(State0),
     next_state(hello, Record, State);
@@ -646,6 +642,9 @@ certify(#client_key_exchange{exchange_keys = #client_diffie_hellman_public{
 certify(Msg, State) ->
     handle_unexpected_message(Msg, certify, State).
 
+-spec cipher(#hello_request{} | #certificate_verify{} | #finished{} | term(),
+	     #state{}) -> gen_fsm_state_return().  
+
 cipher(#hello_request{}, State0) ->
     {Record, State} = next_record(State0),
     next_state(hello, Record, State);
@@ -676,31 +675,14 @@ cipher(#finished{verify_data = Data} = Finished,
 	      role = Role,
 	      session = #session{master_secret = MasterSecret} 
 	      = Session0,
-	      tls_handshake_hashes = Hashes0,
-	     connection_states = ConnectionStates0} = State) ->    
+	      tls_handshake_hashes = Hashes0} = State) ->    
     
     case ssl_handshake:verify_connection(Version, Finished, 
 					 opposite_role(Role), 
                                          MasterSecret, Hashes0) of
         verified ->
 	    Session = register_session(Role, Host, Port, Session0),
-            case Role of
-                client ->
-		    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 ->
-		    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 = 
-									     ConnectionStates,
-									     session = Session,
-									     tls_handshake_hashes =
-									     Hashes}))
-            end;
+	    cipher_role(Role, Data, Session, State);
         #alert{} = Alert ->
 	    handle_own_alert(Alert, Version, cipher, State),
             {stop, normal, State} 
@@ -709,6 +691,8 @@ cipher(#finished{verify_data = Data} = Finished,
 cipher(Msg, State) ->
     handle_unexpected_message(Msg, cipher, State).
 
+-spec connection(#hello_request{} | #client_hello{} | term(),
+		 #state{}) -> gen_fsm_state_return().  
 
 connection(#hello_request{}, #state{host = Host, port = Port,
 				    socket = Socket,
@@ -1039,24 +1023,17 @@ code_change(_OldVsn, StateName, State, _Extra) ->
 %%--------------------------------------------------------------------
 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
-        {ok, Pid} -> 
-	    case socket_control(Socket, Pid, CbModule) of
-		{ok, SslSocket} ->
-		    case handshake(SslSocket, Timeout) of
-			ok  ->
-			    {ok, SslSocket};
-			{error, Reason} ->
-			    {error, Reason} 
-		    end;
-		{error, Reason} ->
-		    {error, Reason}
-            end;
-	{error, Reason} ->
-            {error, Reason}
+    try 
+	{ok, Pid} = ssl_connection_sup:start_child([Role, Host, Port, Socket, 
+						    Opts, User, CbInfo]), 
+	{ok, SslSocket} = socket_control(Socket, Pid, CbModule),
+	ok = handshake(SslSocket, Timeout),
+	{ok, SslSocket} 
+    catch
+	error:{badmatch, {error, _} = Error} ->
+	    Error
     end.
- 
+
 ssl_init(SslOpts, Role) ->
     {ok, CertDbRef, CacheRef, OwnCert} = init_certificates(SslOpts, Role),
     PrivateKey =
@@ -1267,6 +1244,33 @@ do_server_hello(#server_hello{cipher_suite = CipherSuite,
 	    {stop, normal, State0}
     end.
 
+handle_new_session(NewId, CipherSuite, Compression, #state{session = Session0} = State0) ->
+    Session = Session0#session{session_id = NewId,
+			       cipher_suite = CipherSuite,
+			       compression_method = Compression}, 
+    {Record, State} = next_record(State0#state{session = Session}),
+    next_state(certify, Record, State).
+
+handle_resumed_session(SessId, #state{connection_states = ConnectionStates0,
+				      negotiated_version = Version,
+				      host = Host, port = Port,
+				      session_cache = Cache,
+				      session_cache_cb = CacheCb} = State0) ->
+    Session = CacheCb:lookup(Cache, {{Host, Port}, SessId}),
+    case ssl_handshake:master_secret(Version, Session, 
+				     ConnectionStates0, client) of
+	{_, ConnectionStates1} ->	
+	    {Record, State} = 
+		next_record(State0#state{
+			      connection_states = ConnectionStates1,
+			      session = Session}),
+	    next_state(abbreviated, Record, State);
+	#alert{} = Alert ->
+	    handle_own_alert(Alert, Version, hello, State0), 
+	    {stop, normal, State0}
+    end.
+
+
 client_certify_and_key_exchange(#state{negotiated_version = Version} = 
 				State0) ->
     try do_client_certify_and_key_exchange(State0) of 
@@ -1354,9 +1358,7 @@ key_exchange(#state{role = server, key_algorithm = Algo,
 		    transport_cb = Transport
 		   } = State) 
   when Algo == dhe_dss;
-       Algo == dhe_dss_export;
-       Algo == dhe_rsa;
-       Algo == dhe_rsa_export  ->
+       Algo == dhe_rsa ->
 
     Keys = public_key:gen_key(Params),
     ConnectionState = 
@@ -1402,9 +1404,7 @@ key_exchange(#state{role = client,
 		    socket = Socket, transport_cb = Transport,
 		    tls_handshake_hashes = Hashes0} = State) 
   when Algorithm == dhe_dss;
-       Algorithm == dhe_dss_export;
-       Algorithm == dhe_rsa;
-       Algorithm == dhe_rsa_export ->
+       Algorithm == dhe_rsa ->
     Msg =  ssl_handshake:key_exchange(client, {dh, DhPubKey}),
     {BinMsg, ConnectionStates1, Hashes1} =
         encode_handshake(Msg, Version, ConnectionStates0, Hashes0),
@@ -1545,6 +1545,21 @@ verify_dh_params(Signed, Hash, {?'id-dsa', PublicKey, PublicKeyParams}) ->
     public_key:verify_signature(Hash, none, Signed, PublicKey, PublicKeyParams). 
 
 
+cipher_role(client, Data, Session, #state{connection_states = ConnectionStates0} = State) -> 
+    ConnectionStates = ssl_record:set_server_verify_data(current_both, Data, ConnectionStates0),
+    next_state_connection(cipher, ack_connection(State#state{session = Session,
+							     connection_states = ConnectionStates}));
+     
+cipher_role(server, Data, Session,  #state{connection_states = ConnectionStates0} = State) -> 
+    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 = 
+							     ConnectionStates,
+							     session = Session,
+							     tls_handshake_hashes =
+							     Hashes})).
 encode_alert(#alert{} = Alert, Version, ConnectionStates) ->
     ?DBG_TERM(Alert),
     ssl_record:encode_alert_record(Alert, Version, ConnectionStates).
diff --git a/lib/ssl/src/ssl_handshake.erl b/lib/ssl/src/ssl_handshake.erl
index f7e3e392ec..3811906d77 100644
--- a/lib/ssl/src/ssl_handshake.erl
+++ b/lib/ssl/src/ssl_handshake.erl
@@ -42,16 +42,15 @@
          encode_handshake/3, init_hashes/0, 
          update_hashes/2, decrypt_premaster_secret/2]).
 
+-type tls_handshake()  :: #client_hello{} | #server_hello{} | #server_hello_done{} |
+#certificate{} | #client_key_exchange{} | #finished{} | #certificate_verify{}.
+
 %%====================================================================
 %% Internal application API
 %%====================================================================
 %%--------------------------------------------------------------------
-%% Function: client_hello(Host, Port, ConnectionStates, SslOpts, Cert, Renegotiation) -> 
-%%                                                  #client_hello{} 
-%%      Host
-%%      Port
-%%      ConnectionStates = #connection_states{}
-%%      SslOpts = #ssl_options{}
+-spec client_hello(host(), port_num(), #connection_states{},
+		   #ssl_options{}, binary(), boolean()) -> #client_hello{}.
 %%
 %% Description: Creates a client hello message.
 %%--------------------------------------------------------------------
@@ -79,13 +78,8 @@ client_hello(Host, Port, ConnectionStates, #ssl_options{versions = Versions,
 		 }.
 
 %%--------------------------------------------------------------------
-%% Function: server_hello(SessionId, Version, 
-%%                        ConnectionStates, Renegotiation) -> #server_hello{} 
-%%      SessionId
-%%      Version
-%%      ConnectionStates
-%%      Renegotiation 
-%%	
+-spec server_hello(session_id(), tls_version(), #connection_states{}, 
+		   boolean()) -> #server_hello{}.
 %%
 %% Description: Creates a server hello message.
 %%--------------------------------------------------------------------
@@ -103,7 +97,7 @@ server_hello(SessionId, Version, ConnectionStates, Renegotiation) ->
 		 }.
 
 %%--------------------------------------------------------------------
-%% Function: hello_request() -> #hello_request{} 
+-spec hello_request() -> #hello_request{}.
 %%
 %% Description: Creates a hello request message sent by server to 
 %% trigger renegotiation.
@@ -112,15 +106,12 @@ hello_request() ->
     #hello_request{}.
 
 %%--------------------------------------------------------------------
-%% Function: hello(Hello, Info, Renegotiation) -> 
-%%                                   {Version, Id, NewConnectionStates} |
-%%                                   #alert{}
-%%
-%%      Hello = #client_hello{} | #server_hello{}
-%%      Info = ConnectionStates | {Port, #ssl_options{}, Session, 
-%%                                 Cahce, CahceCb, ConnectionStates}
-%%      ConnectionStates = #connection_states{}
-%%      Renegotiation = boolean()
+-spec hello(#server_hello{} | #client_hello{}, #ssl_options{},
+ 	    #connection_states{} | {port_num(), #session{}, cache_ref(),
+ 				    atom(), #connection_states{}, binary()},
+ 	    boolean()) -> {tls_version(), session_id(), #connection_states{}}| 
+ 			  {tls_version(), {resumed | new, session_id()}, 
+ 			   #connection_states{}} | #alert{}.
 %%
 %% Description: Handles a recieved hello message
 %%--------------------------------------------------------------------
@@ -183,12 +174,9 @@ hello(#client_hello{client_version = ClientVersion, random = Random,
     end.
 
 %%--------------------------------------------------------------------
-%% Function: certify(Certs, CertDbRef, MaxPathLen) ->
-%%                                 {PeerCert, PublicKeyInfo}  | #alert{}
-%%
-%%      Certs = #certificate{}
-%%	CertDbRef = reference()
-%%      MaxPathLen = integer() | nolimit
+-spec certify(#certificate{}, term(), integer() | nolimit,
+	      verify_peer | verify_none, fun(), fun(), 
+	      client | server) ->  {der_cert(), public_key_info()} | #alert{}.
 %%
 %% Description: Handles a certificate handshake message
 %%--------------------------------------------------------------------
@@ -244,10 +232,7 @@ certify(#certificate{asn1_certificates = ASN1Certs}, CertDbRef,
     end.
 	    
 %%--------------------------------------------------------------------
-%% Function: certificate(OwnCert, CertDbRef, Role) -> #certificate{}
-%%
-%%      OwnCert = binary()
-%%      CertDbRef = term() as returned by ssl_certificate_db:create()
+-spec certificate(der_cert(), term(), client | server) -> #certificate{}. 
 %%
 %% Description: Creates a certificate message.
 %%--------------------------------------------------------------------
@@ -273,10 +258,10 @@ certificate(OwnCert, CertDbRef, server) ->
     end.
 
 %%--------------------------------------------------------------------
-%% Function: client_certificate_verify(Cert, ConnectionStates) -> 
-%%                                          #certificate_verify{} | ignore
-%% Cert             = #'OTPcertificate'{}
-%% ConnectionStates = #connection_states{}
+-spec client_certificate_verify(undefined | der_cert(), binary(),
+				tls_version(), key_algo(), private_key(),
+				{binary(), binary()}) ->  
+    #certificate_verify{} | ignore.
 %%
 %% Description: Creates a certificate_verify message, called by the client.
 %%--------------------------------------------------------------------
@@ -298,10 +283,9 @@ client_certificate_verify(OwnCert, MasterSecret, Version, Algorithm,
     end.
 
 %%--------------------------------------------------------------------
-%% Function: certificate_verify(Signature, PublicKeyInfo) -> valid | #alert{}
-%%
-%% Signature     = binary()
-%% PublicKeyInfo = {Algorithm, PublicKey, PublicKeyParams}
+-spec certificate_verify(binary(), public_key_info(), tls_version(),
+			 binary(), key_algo(), 
+			 {binary(), binary()}) -> valid | #alert{}.
 %%
 %% Description: Checks that the certificate_verify message is valid.
 %%--------------------------------------------------------------------
@@ -325,8 +309,8 @@ certificate_verify(Signature, {_, PublicKey, PublicKeyParams}, Version,
      public_key:verify_signature(Hashes, sha, Signature, PublicKey, PublicKeyParams). 
 
 %%--------------------------------------------------------------------
-%% Function: certificate_request(ConnectionStates, CertDbRef) -> 
-%%                                                #certificate_request{}
+-spec certificate_request(#connection_states{}, certdb_ref()) -> 
+    #certificate_request{}.
 %%
 %% Description: Creates a certificate_request message, called by the server.
 %%--------------------------------------------------------------------
@@ -342,11 +326,12 @@ certificate_request(ConnectionStates, CertDbRef) ->
 		   }.
 
 %%--------------------------------------------------------------------
-%% Function: key_exchange(Role, Secret, Params) -> 
-%%                         #client_key_exchange{} | #server_key_exchange{}
-%%
-%%      Secret -
-%%      Params - 
+-spec key_exchange(client | server, 
+		   {premaster_secret, binary(), public_key_info()} |
+		   {dh, binary()} |
+		   {dh, binary(), #'DHParameter'{}, key_algo(),
+		   binary(), binary(), private_key()}) ->
+    #client_key_exchange{} | #server_key_exchange{}.
 %%
 %% Description: Creates a keyexchange message.
 %%--------------------------------------------------------------------
@@ -382,15 +367,9 @@ key_exchange(server, {dh, {<<?UINT32(Len), PublicKey:Len/binary>>, _},
 			 signed_params = Signed}.
 
 %%--------------------------------------------------------------------
-%% Function: master_secret(Version, Session/PremasterSecret, 
-%%                         ConnectionStates, Role) -> 
-%%                          {MasterSecret, NewConnectionStates} | #alert{}
-%%      Version = #protocol_version{}
-%%      Session = #session{} (session contains master secret)
-%%      PremasterSecret = binary()  
-%%      ConnectionStates = #connection_states{}
-%%      Role = client | server
-%%
+-spec master_secret(tls_version(), #session{} | binary(), #connection_states{},
+		   client | server) -> {binary(), #connection_states{}} | #alert{}.
+%%    
 %% Description: Sets or calculates the master secret and calculate keys,
 %% updating the pending connection states. The Mastersecret and the update
 %% connection states are returned or an alert if the calculation fails.
@@ -427,9 +406,8 @@ master_secret(Version, PremasterSecret, ConnectionStates, Role) ->
     end.
 
 %%--------------------------------------------------------------------
-%% Function: finished(Version, Role, MacSecret, Hashes) -> #finished{}
-%%
-%%      ConnectionStates = #connection_states{}
+-spec finished(tls_version(), client | server, binary(), {binary(), binary()}) ->
+    #finished{}.
 %%
 %% Description: Creates a handshake finished message
 %%-------------------------------------------------------------------
@@ -438,15 +416,8 @@ finished(Version, Role, MasterSecret, {Hashes, _}) -> % use the current hashes
 	      calc_finished(Version, Role, MasterSecret, Hashes)}.
 
 %%--------------------------------------------------------------------
-%% Function: verify_connection(Finished, Role, 
-%%                             MasterSecret, Hashes) -> verified | #alert{}
-%% 
-%% Finished = #finished{}
-%% Role = client | server - the role of the process that sent the finished
-%% message.
-%% MasterSecret = binary()
-%% Hashes = binary() -  {md5_hash, sha_hash} 
-%%
+-spec verify_connection(tls_version(), #finished{}, client | server, binary(), 
+			{binary(), binary()}) -> verified | #alert{}.
 %%
 %% Description: Checks the ssl handshake finished message to verify
 %%              the connection.
@@ -462,17 +433,18 @@ verify_connection(Version, #finished{verify_data = Data},
 	_E ->
  	    ?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE)
     end.
-	    
+%%--------------------------------------------------------------------
+-spec server_hello_done() ->  #server_hello_done{}.
+%%     
+%% Description: Creates a server hello done message.
+%%--------------------------------------------------------------------	    
 server_hello_done() ->
     #server_hello_done{}.
 
 %%--------------------------------------------------------------------
-%% Function: encode_handshake(HandshakeRec) -> BinHandshake
-%% HandshakeRec = #client_hello | #server_hello{} | server_hello_done |
-%%              #certificate{} | #client_key_exchange{} | #finished{} |
-%%              #client_certify_request{}
+-spec encode_handshake(tls_handshake(), tls_version(), key_algo()) -> binary().
 %%     
-%% encode a handshake packet to binary
+%% Description: Encode a handshake packet to binary
 %%--------------------------------------------------------------------
 encode_handshake(Package, Version, KeyAlg) ->
     SigAlg = sig_alg(KeyAlg),
@@ -481,12 +453,11 @@ encode_handshake(Package, Version, KeyAlg) ->
     [MsgType, ?uint24(Len), Bin].
 
 %%--------------------------------------------------------------------
-%% Function: get_tls_handshake(Data, Buffer) -> Result
-%%      Result = {[#handshake{}], [Raw], NewBuffer}
-%%      Data = Buffer = NewBuffer = Raw = binary()
+-spec get_tls_handshake(binary(), binary(), key_algo(), tls_version()) ->
+     {[tls_handshake()], [binary()], binary()}.
 %%
 %% Description: Given buffered and new data from ssl_record, collects
-%% and returns it as a list of #handshake, also returns leftover
+%% and returns it as a list of handshake messages, also returns leftover
 %% data.
 %%--------------------------------------------------------------------
 get_tls_handshake(Data, <<>>, KeyAlg, Version) ->
@@ -495,6 +466,9 @@ get_tls_handshake(Data, Buffer, KeyAlg, Version) ->
     get_tls_handshake_aux(list_to_binary([Buffer, Data]), 
 			  KeyAlg, Version, []).
 
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
 get_tls_handshake_aux(<<?BYTE(Type), ?UINT24(Length), 
 		       Body:Length/binary,Rest/binary>>, KeyAlg, 
 		      Version, Acc) ->
@@ -504,9 +478,6 @@ get_tls_handshake_aux(<<?BYTE(Type), ?UINT24(Length),
 get_tls_handshake_aux(Data, _KeyAlg, _Version, Acc) ->
     {lists:reverse(Acc), Data}.
 
-%%--------------------------------------------------------------------
-%%% Internal functions
-%%--------------------------------------------------------------------
 verify_bool(verify_peer) ->
     true;
 verify_bool(verify_none) ->
diff --git a/lib/ssl/src/ssl_internal.hrl b/lib/ssl/src/ssl_internal.hrl
index fdc0c33750..884b3d6ed5 100644
--- a/lib/ssl/src/ssl_internal.hrl
+++ b/lib/ssl/src/ssl_internal.hrl
@@ -23,6 +23,8 @@
 -ifndef(ssl_internal).
 -define(ssl_internal, true).
 
+-include_lib("public_key/include/public_key.hrl"). 
+
 %% basic binary constructors
 -define(BOOLEAN(X),  X:8/unsigned-big-integer).
 -define(BYTE(X),     X:8/unsigned-big-integer).
@@ -88,6 +90,21 @@
 	  active = true
 	 }).
 
+-type reason()            :: term().
+-type host()		  :: string() | tuple().
+-type port_num()	  :: integer().
+-type session_id()        :: binary().
+-type tls_version()       :: {integer(), integer()}.
+-type cache_ref()         :: term(). 
+-type certdb_ref()        :: term(). 
+-type key_algo()          :: rsa | dhe_rsa | dhe_dss.
+-type oid_algo()          :: integer().
+-type public_key()        :: #'RSAPublicKey'{} | integer().
+-type public_key_params() :: #'Dss-Parms'{} | term().
+-type public_key_info()   :: {oid_algo(), public_key(), public_key_params()}.
+-type der_cert()          :: binary().
+-type private_key()       :: #'RSAPrivateKey'{} | #'DSAPrivateKey'{}.
+
 -endif. % -ifdef(ssl_internal).
 
 
diff --git a/lib/ssl/src/ssl_session.erl b/lib/ssl/src/ssl_session.erl
index bcb10daf69..e9755cb0e1 100644
--- a/lib/ssl/src/ssl_session.erl
+++ b/lib/ssl/src/ssl_session.erl
@@ -32,11 +32,10 @@
 
 -define(GEN_UNIQUE_ID_MAX_TRIES, 10).
 
+-type seconds()   :: integer(). 
+
 %%--------------------------------------------------------------------
-%% Function: is_new(ClientSuggestedId, ServerDecidedId) -> true | false
-%%
-%%      ClientSuggestedId = binary() 
-%%      ServerDecidedId = binary()
+-spec is_new(binary(), binary()) -> boolean().
 %%
 %% Description: Checks if the session id decided by the server is a
 %%              new or resumed sesion id.
@@ -45,17 +44,11 @@ is_new(<<>>, _) ->
     true;
 is_new(SessionId, SessionId) ->
     false;
-is_new(_, _) ->
+is_new(_ClientSuggestion, _ServerDecision) ->
     true.
 
 %%--------------------------------------------------------------------
-%% Function: id(ClientInfo, Cache, CacheCb) -> SessionId 
-%%
-%%      ClientInfo = {HostIP, Port, SslOpts}
-%%      HostIP = ipadress()
-%%      Port = integer() 
-%%      CacheCb = atom()
-%%      SessionId = binary()
+-spec id({host(), port_num(), #ssl_options{}}, cache_ref(), atom()) -> binary().
 %%
 %% Description: Should be called by the client side to get an id 
 %%              for the client hello message.
@@ -69,14 +62,8 @@ id(ClientInfo, Cache, CacheCb) ->
     end.
 
 %%--------------------------------------------------------------------
-%% Function: id(Port, SuggestedSessionId, ReuseFun, CacheCb,
-%%              SecondLifeTime) -> SessionId 
-%%
-%%      Port = integer() 
-%%      SuggestedSessionId = SessionId = binary()
-%%      ReuseFun = fun(SessionId, PeerCert, Compression, CipherSuite) -> 
-%%                                                             true | false 
-%%      CacheCb = atom()
+-spec id(port_num(), binary(), #ssl_options{}, cache_ref(), 
+	 atom(), seconds()) -> binary().
 %%
 %% Description: Should be called by the server side to get an id 
 %%              for the server hello message.
@@ -95,10 +82,7 @@ id(Port, SuggestedSessionId, #ssl_options{reuse_sessions = ReuseEnabled,
 	    new_id(Port, ?GEN_UNIQUE_ID_MAX_TRIES, Cache, CacheCb)
     end.
 %%--------------------------------------------------------------------
-%% Function: valid_session(Session, LifeTime) -> true | false 
-%%
-%%	Session  = #session{}
-%%      LifeTime = integer() - seconds
+-spec valid_session(#session{}, seconds()) -> boolean().
 %%
 %% Description: Check that the session has not expired
 %%--------------------------------------------------------------------
diff --git a/lib/ssl/src/ssl_session_cache.erl b/lib/ssl/src/ssl_session_cache.erl
index 1f2d1fc7d3..823bf7acfa 100644
--- a/lib/ssl/src/ssl_session_cache.erl
+++ b/lib/ssl/src/ssl_session_cache.erl
@@ -22,13 +22,16 @@
 
 -behaviour(ssl_session_cache_api).
 
+-include("ssl_handshake.hrl").
+-include("ssl_internal.hrl").
+
 -export([init/1, terminate/1, lookup/2, update/3, delete/2, foldl/3, 
 	 select_session/2]). 
 
+-type key() :: {{host(), port_num()}, session_id()} |  {port_num(), session_id()}.
+
 %%--------------------------------------------------------------------
-%% Function: init() -> Cache  
-%%
-%%	Cache - Reference to the cash (opaque)    
+-spec init(list()) -> cache_ref(). %% Returns reference to the cache (opaque)    
 %%
 %% Description: Return table reference. Called by ssl_manager process. 
 %%--------------------------------------------------------------------
@@ -36,9 +39,7 @@ init(_) ->
     ets:new(cache_name(), [set, protected]).
 
 %%--------------------------------------------------------------------
-%% Function: terminate(Cache) -> 
-%%
-%%      Cache - as returned by create/0
+-spec terminate(cache_ref()) -> any(). %%    
 %%
 %% Description: Handles cache table at termination of ssl manager. 
 %%--------------------------------------------------------------------
@@ -46,9 +47,7 @@ terminate(Cache) ->
     ets:delete(Cache).
 
 %%--------------------------------------------------------------------
-%% Function: lookup(Cache, Key) -> Session | undefined   
-%%      Cache - as returned by create/0   
-%%      Session = #session{}
+-spec lookup(cache_ref(), key()) -> #session{} | undefined.
 %%
 %% Description: Looks up a cach entry. Should be callable from any
 %% process.
@@ -62,9 +61,7 @@ lookup(Cache, Key) ->
     end.
 
 %%--------------------------------------------------------------------
-%% Function: update(Cache, Key, Session) -> _
-%%      Cache - as returned by create/0
-%%      Session = #session{}
+-spec update(cache_ref(), key(), #session{}) -> any().
 %%
 %% Description: Caches a new session or updates a already cached one.
 %% Will only be called from the ssl_manager process.
@@ -73,11 +70,7 @@ update(Cache, Key, Session) ->
     ets:insert(Cache, {Key, Session}).
 
 %%--------------------------------------------------------------------
-%% Function: delete(Cache, HostIP, Port, Id) -> _
-%%      Cache - as returned by create/0   
-%%      HostIP =  Host = string() | ipadress()
-%%      Port =  integer()
-%%      Id = 
+-spec delete(cache_ref(), key()) -> any().
 %%
 %% Description: Delets a cache entry.
 %% Will only be called from the ssl_manager process.
@@ -86,28 +79,19 @@ delete(Cache, Key) ->
     ets:delete(Cache, Key).
 
 %%--------------------------------------------------------------------
-%% Function: foldl(Fun, Acc0, Cache) -> Acc
-%%   
-%%	Fun  - fun()
-%%      Acc0  - term()
-%%      Cache  - cache_ref()
-%%
+-spec foldl(fun(), term(), cache_ref()) -> term().
 %%
 %% Description: Calls Fun(Elem, AccIn) on successive elements of the
 %% cache, starting with AccIn == Acc0. Fun/2 must return a new
 %% accumulator which is passed to the next call. The function returns
-%% the final value of the accumulator. Acc0 is returned if the cache is
-%% empty. 
-%% Should be callable from any process
+%% the final value of the accumulator. Acc0 is returned if the cache
+%% is empty.Should be callable from any process
 %%--------------------------------------------------------------------
 foldl(Fun, Acc0, Cache) ->
     ets:foldl(Fun, Acc0, Cache).
   
 %%--------------------------------------------------------------------
-%% Function: select_session(Cache, PartialKey) -> [Sessions]
-%%
-%%     Cache - as returned by create/0   
-%%     PartialKey - opaque  Key = {PartialKey, SessionId}
+-spec select_session(cache_ref(), {host(), port_num()} | port_num()) -> [#session{}].
 %%
 %% Description: Selects a session that could be reused. Should be callable
 %% from any process.
@@ -119,6 +103,5 @@ select_session(Cache, PartialKey) ->
 %%--------------------------------------------------------------------
 %%% Internal functions
 %%--------------------------------------------------------------------
-
 cache_name() ->
     ssl_otp_session_cache.
diff --git a/lib/ssl/src/ssl_ssl3.erl b/lib/ssl/src/ssl_ssl3.erl
index 88b801d46b..94c9296160 100644
--- a/lib/ssl/src/ssl_ssl3.erl
+++ b/lib/ssl/src/ssl_ssl3.erl
@@ -38,6 +38,8 @@
 %% Internal application API
 %%====================================================================
 
+-spec master_secret(binary(), binary(), binary()) -> binary().
+
 master_secret(PremasterSecret, ClientRandom, ServerRandom) ->
     ?DBG_HEX(PremasterSecret),
     ?DBG_HEX(ClientRandom),
@@ -57,6 +59,8 @@ master_secret(PremasterSecret, ClientRandom, ServerRandom) ->
     ?DBG_HEX(B),
     B.
 
+-spec finished(client | server, binary(), {binary(), binary()}) -> binary().
+
 finished(Role, MasterSecret, {MD5Hash, SHAHash}) ->
    %%  draft-ietf-tls-ssl-version3-00 - 5.6.9 Finished
    %%     struct {
@@ -75,6 +79,8 @@ finished(Role, MasterSecret, {MD5Hash, SHAHash}) ->
     SHA = handshake_hash(?SHA, MasterSecret, Sender, SHAHash),
     <<MD5/binary, SHA/binary>>.
 
+-spec certificate_verify(key_algo(), binary(), {binary(), binary()}) -> binary().
+
 certificate_verify(Algorithm, MasterSecret, {MD5Hash, SHAHash}) 
   when Algorithm == rsa; Algorithm == dhe_rsa ->
      %% md5_hash
@@ -94,6 +100,8 @@ certificate_verify(dhe_dss, MasterSecret, {_, SHAHash}) ->
      %%               SHA(handshake_messages + master_secret + pad_1));
     handshake_hash(?SHA, MasterSecret, undefined, SHAHash).
 
+-spec mac_hash(integer(), binary(), integer(), integer(), integer(), binary()) -> binary(). 
+
 mac_hash(Method, Mac_write_secret, Seq_num, Type, Length, Fragment) ->
     %% draft-ietf-tls-ssl-version3-00 - 5.2.3.1 
     %% hash(MAC_write_secret + pad_2 +
@@ -113,6 +121,10 @@ mac_hash(Method, Mac_write_secret, Seq_num, Type, Length, Fragment) ->
     ?DBG_HEX(Mac),
     Mac.
 
+-spec setup_keys(binary(), binary(), binary(), binary(), 
+		 integer(), integer(), binary()) -> {binary(), binary(), binary(), 
+						     binary(), binary(), binary()}.  
+
 setup_keys(MasterSecret, ServerRandom, ClientRandom, HS, KML, _EKML, IVS) ->
     KeyBlock = generate_keyblock(MasterSecret, ServerRandom, ClientRandom,
 				 2*(HS+KML+IVS)),
@@ -136,6 +148,8 @@ setup_keys(MasterSecret, ServerRandom, ClientRandom, HS, KML, _EKML, IVS) ->
     {ClientWriteMacSecret, ServerWriteMacSecret, ClientWriteKey,
      ServerWriteKey, ClientIV, ServerIV}.
 
+-spec suites() -> list().
+
 suites() ->
     [ 
       ?TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
diff --git a/lib/ssl/src/ssl_tls1.erl b/lib/ssl/src/ssl_tls1.erl
index 70db632835..f4a12a5a52 100644
--- a/lib/ssl/src/ssl_tls1.erl
+++ b/lib/ssl/src/ssl_tls1.erl
@@ -36,6 +36,8 @@
 %% Internal application API
 %%====================================================================
 
+-spec master_secret(binary(), binary(), binary()) -> binary().
+
 master_secret(PreMasterSecret, ClientRandom, ServerRandom) ->
     %% RFC 2246 & 4346 - 8.1 %% master_secret = PRF(pre_master_secret,
     %%                           "master secret", ClientHello.random +
@@ -43,6 +45,8 @@ master_secret(PreMasterSecret, ClientRandom, ServerRandom) ->
     prf(PreMasterSecret, <<"master secret">>, 
 	[ClientRandom, ServerRandom], 48).
 
+-spec finished(client | server, binary(), {binary(), binary()}) -> binary().
+
 finished(Role, MasterSecret, {MD5Hash, SHAHash}) ->
     %% RFC 2246 & 4346 - 7.4.9. Finished
     %% struct {
@@ -56,6 +60,7 @@ finished(Role, MasterSecret, {MD5Hash, SHAHash}) ->
     SHA = hash_final(?SHA, SHAHash),
     prf(MasterSecret, finished_label(Role), [MD5, SHA], 12).
 
+-spec certificate_verify(key_algo(), {binary(), binary()}) -> binary().
 
 certificate_verify(Algorithm, {MD5Hash, SHAHash}) when Algorithm == rsa;
 						       Algorithm == dhe_rsa ->
@@ -65,7 +70,11 @@ certificate_verify(Algorithm, {MD5Hash, SHAHash}) when Algorithm == rsa;
 
 certificate_verify(dhe_dss, {_, SHAHash}) ->
     hash_final(?SHA, SHAHash).
-    
+
+-spec setup_keys(binary(), binary(), binary(), integer(), 
+		 integer(), integer()) -> {binary(), binary(), binary(), 
+					  binary(), binary(), binary()}.  
+
 setup_keys(MasterSecret, ServerRandom, ClientRandom, HashSize,
 	   KeyMatLen, IVSize) ->
     %% RFC 2246 - 6.3. Key calculation
@@ -112,6 +121,9 @@ setup_keys(MasterSecret, ServerRandom, ClientRandom, HashSize,
 %%     {ClientWriteMacSecret, ServerWriteMacSecret, ClientWriteKey,
 %%      ServerWriteKey, undefined, undefined}.
 
+-spec mac_hash(integer(), binary(), integer(), integer(), tls_version(),
+	       integer(), binary()) -> binary(). 
+
 mac_hash(Method, Mac_write_secret, Seq_num, Type, {Major, Minor}, 
 	 Length, Fragment) ->
     %% RFC 2246 & 4346 - 6.2.3.1.
@@ -132,6 +144,8 @@ mac_hash(Method, Mac_write_secret, Seq_num, Type, {Major, Minor},
     ?DBG_HEX(Mac),
     Mac.
 
+-spec suites() -> list().
+    
 suites() ->
     [ 
       ?TLS_DHE_RSA_WITH_AES_256_CBC_SHA,