diff --git a/library/ssl_tls13_client.c b/library/ssl_tls13_client.c
index 1516523..a2e5f33 100644
--- a/library/ssl_tls13_client.c
+++ b/library/ssl_tls13_client.c
@@ -1328,7 +1328,6 @@
 
     handshake->transform_handshake = transform_handshake;
     mbedtls_ssl_set_inbound_transform( ssl, transform_handshake );
-    mbedtls_ssl_set_outbound_transform( ssl, ssl->handshake->transform_handshake );
 
     MBEDTLS_SSL_DEBUG_MSG( 1, ( "Switch to handshake keys for inbound traffic" ) );
     ssl->session_in = ssl->session_negotiate;
@@ -1612,6 +1611,7 @@
     if( ret != 0 )
         return( ret );
 
+    mbedtls_ssl_set_outbound_transform( ssl, ssl->handshake->transform_handshake );
     mbedtls_ssl_handshake_set_state( ssl, MBEDTLS_SSL_CLIENT_FINISHED );
     return( 0 );
 }
