added internal buffers to encrypted sockets

src/client/ServerConnection.c

@@ -5,7 +5,7 @@ void ServerConnection_close(ServerConnection* conn){
     if(conn == NULL)
         return;
     RSA_destroyPublicKey(&conn->server_pk);
-    socket_close(conn->sock.sock);
+    EncryptedSocketTCP_destroy(&conn->sock);
     free(conn->session_key.data);
     free(conn);
 }
@@ -63,78 +63,80 @@ Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_creden
     try(Socket _s, i, socket_open_TCP());
     // TODO: set socket timeout to 5 seconds
     try_void(socket_connect(_s, conn->server_end));
-    EncryptedSocketTCP_construct(&conn->sock, _s, conn->session_key);
+    EncryptedSocketTCP_construct(&conn->sock, _s, NETWORK_BUFFER_SIZE, conn->session_key);
     
-    Array(u8) enc_buf = Array_alloc_size(8*1024);
+    Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
-    Defer(free(enc_buf.data));
+    Defer(free(buffer.data));
-    Array(u8) dec_buf = Array_alloc_size(8*1024);
-    Defer(free(dec_buf.data));
-    u32 enc_size = 0, dec_size = 0;
 
-    // construct ClientHandshake in dec_buf
+    // construct PacketHeader and ClientHandshake in buffer
-    try_void(ClientHandshake_tryConstruct((ClientHandshake*)dec_buf.data, conn->session_key));
+    PacketHeader_construct(buffer.data, PROTOCOL_VERSION,
-    dec_size = sizeof(ClientHandshake);
+        PacketType_ClientHandshake, sizeof(ClientHandshake));
-    // encrypt by server public key
+    ClientHandshake_construct(
-    try(enc_size, u, 
+        Array_sliceAfter(buffer, sizeof(PacketHeader)).data,
+        conn->session_key);
+    u32 header_and_message_size = sizeof(PacketHeader) + sizeof(ClientHandshake);
+    // encrypt message by server public key
+    Array(u8) bufferPart_encryptedClientHandshake = Array_sliceAfter(buffer, header_and_message_size);
+    try(u32 rsa_enc_size, u, 
         RSAEncryptor_encrypt(
-            &conn->rsa_enc, 
+            &conn->rsa_enc,
-            Array_sliceBefore(dec_buf, dec_size), 
+            Array_sliceBefore(buffer, header_and_message_size),
-            enc_buf
+            bufferPart_encryptedClientHandshake
         )
     );
-    try_void(socket_send(conn->sock.sock, Array_sliceBefore(enc_buf, enc_size)));
+    bufferPart_encryptedClientHandshake.size = rsa_enc_size;
+    // send encrypted message
+    try_void(socket_send(conn->sock.sock, bufferPart_encryptedClientHandshake));
     
     // receive server response
-    enc_size = AESStreamEncryptor_calcDstSize(sizeof(PacketHeader));
+    try_void( 
-    try(dec_size, u, 
         EncryptedSocketTCP_recv(&conn->sock,
-            Array_sliceBefore(enc_buf, enc_size),
+            Array_sliceBefore(buffer, sizeof(PacketHeader)),
-            dec_buf,
             SocketRecvFlag_WaitAll
         )
     );
-    try_assert(dec_size == sizeof(PacketHeader));
+    PacketHeader* packet_header = buffer.data;
-    PacketHeader* packet_header = dec_buf.data;
     try_void(PacketHeader_validateMagic(packet_header));
     
     // handle server response
     switch(packet_header->type){
         case PacketType_ErrorMessage: {
-            Array(u8) err_buf = Array_alloc_size(packet_header->content_size + 1);
+            u32 err_msg_size = packet_header->content_size;
+            if(err_msg_size > conn->sock.recv_buf.size)
+                err_msg_size = conn->sock.recv_buf.size;
+            Array(u8) err_buf = Array_alloc_size(err_msg_size + 1);
             bool err_msg_completed = false;
             Defer(
                 if(!err_msg_completed)
                     free(err_buf.data);
             );
 
-            // receive error message of length packet_header->content_size
+            // receive error message
-            enc_size = packet_header->content_size;
-            if(enc_size > enc_buf.size)
-                enc_size = enc_buf.size;
             try_void(
                 EncryptedSocketTCP_recv(
                     &conn->sock,
-                    Array_sliceBefore(enc_buf, enc_size),
+                    Array_sliceBefore(err_buf, err_msg_size),
-                    err_buf,
                     SocketRecvFlag_WaitAll
                 )
             );
 
-            ((u8*)err_buf.data)[enc_size] = 0;
+            ((u8*)err_buf.data)[err_msg_size] = 0;
             err_msg_completed = true;
             Return RESULT_ERROR((char*)err_buf.data, true);
         }
         case PacketType_ServerHandshake: {
-            enc_size = sizeof(ServerHandshake) - sizeof(PacketHeader);
+            Array(u8) bufferPart_ServerHandshake = { 
+                .data = (u8*)buffer.data + sizeof(PacketHeader),
+                .size = sizeof(ServerHandshake)
+            };
             try_void(
                 EncryptedSocketTCP_recv(
                     &conn->sock,
-                    Array_sliceBefore(enc_buf, enc_size),
+                    bufferPart_ServerHandshake,
-                    dec_buf,
                     SocketRecvFlag_WaitAll
                 )
             );
-            ServerHandshake* server_handshake = dec_buf.data;
+            ServerHandshake* server_handshake = bufferPart_ServerHandshake.data;
             conn->session_id = server_handshake->session_id;
             break;
         }

src/cryptography/AES.c

@@ -176,13 +176,14 @@ void AESStreamDecryptor_construct(AESStreamDecryptor* ptr, Array(u8) key, const
 
 Result(u32) AESStreamDecryptor_decrypt(AESStreamDecryptor* ptr, Array(u8) src, Array(u8) dst){
     Deferral(4);
-    u32 decrypted_size = __AESStreamDecryptor_calcDstSize(src.size);
-    try_assert(dst.size >= decrypted_size);
 
     // if it is the beginning of the stream, read IV
     if(ptr->block_counter == 0){
         __Array_readNext(ptr->iv, &src, __AES_STREAM_IV_SIZE);
     }
+    // size without IV
+    u32 decrypted_size = src.size;
+    try_assert(dst.size >= decrypted_size);
 
     // decrypt full buffers
     while(src.size > __AES_BUFFER_SIZE){

src/cryptography/AES.h

@@ -89,7 +89,7 @@ typedef struct AESStreamEncryptor {
 void AESStreamEncryptor_construct(AESStreamEncryptor* ptr, Array(u8) key, const br_block_ctr_class* ctr_class);
 
 /// use this only at the beginning of the stream
-#define AESStreamEncryptor_calcDstSize(src_size) (src_size + __AES_BLOCK_IV_SIZE)
+#define AESStreamEncryptor_calcDstSize(src_size) (src_size + __AES_STREAM_IV_SIZE)
 
 /// @brief If ptr->block_counter == 0, writes random IV to `dst`. After that writes encrypted data to dst.
 /// @param src array of any size
@@ -119,5 +119,3 @@ void AESStreamDecryptor_construct(AESStreamDecryptor* ptr, Array(u8) key, const
 /// @param dst array of size >= src.size
 /// @return size of decrypted data
 Result(u32) AESStreamDecryptor_decrypt(AESStreamDecryptor* ptr, Array(u8) src, Array(u8) dst);
-
-#define __AESStreamDecryptor_calcDstSize(src_size) (src_size - __AES_BLOCK_IV_SIZE)

src/network/encrypted_sockets.c

@@ -1,63 +1,134 @@
 #include "encrypted_sockets.h"
 
-void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr, Socket sock, Array(u8) aes_key)
+void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr, 
+    Socket sock, u32 crypto_buffer_size, Array(u8) aes_key)
 {
     ptr->sock = sock;
     AESStreamEncryptor_construct(&ptr->enc, aes_key, AESStream_DEFAULT_CLASS);
     AESStreamDecryptor_construct(&ptr->dec, aes_key, AESStream_DEFAULT_CLASS);
+    ptr->recv_buf = Array_alloc_size(crypto_buffer_size);
+    ptr->send_buf = Array_alloc_size(crypto_buffer_size);
 }
 
+void EncryptedSocketTCP_destroy(EncryptedSocketTCP* ptr){
+    socket_close(ptr->sock);
+    free(ptr->recv_buf.data);
+    free(ptr->send_buf.data);
+}
 
-Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
+Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr, 
-    Array(u8) decrypted_buf, Array(u8) encrypted_buf)
+    Array(u8) buffer)
 {
-    Deferral(4);
+    Deferral(1);
-    try(u32 encrypted_size, u, AESStreamEncryptor_encrypt(&ptr->enc, decrypted_buf, encrypted_buf));
+
-    encrypted_buf.size = encrypted_size;
+    try(u32 encrypted_size, u,
-    try_void(socket_send(ptr->sock, encrypted_buf));
+        AESStreamEncryptor_encrypt(
+            &ptr->enc,
+            buffer,
+            ptr->send_buf
+        )
+    );
+    try_void(
+        socket_send(
+            ptr->sock,
+            Array_sliceBefore(ptr->send_buf, encrypted_size)
+        )
+    );
+
     Return RESULT_VOID;
 }
 
-Result(i32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
+Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr, 
-    Array(u8) encrypted_buf, Array(u8) decrypted_buf,
+    Array(u8) buffer, SocketRecvFlag flags)
-    SocketRecvFlag flags)
 {
-    Deferral(4);
+    Deferral(1);
-    try(i32 received_size, i, socket_recv(ptr->sock, encrypted_buf, flags));
+
-    //TODO: return error if WaitAll flag was set and socket closed before filling the buffer
+    u32 size_to_receive = buffer.size;
-    //TODO: return something when received_size == 0 (socket has been closed)
+    if(ptr->dec.block_counter == 0){
-    encrypted_buf.size = received_size;
+        // There is some metadata at the beginning of AES stream
-    try(i32 decrypted_size, u, AESStreamDecryptor_decrypt(&ptr->dec, encrypted_buf, decrypted_buf));
+        size_to_receive = AESStreamEncryptor_calcDstSize(size_to_receive);
-    Return RESULT_VALUE(i, decrypted_size);
+    }
+    try(i32 received_size, i,
+        socket_recv(
+            ptr->sock,
+            Array_sliceBefore(ptr->recv_buf, size_to_receive),
+            flags
+        )
+    );
+    try(u32 decrypted_size, u,
+        AESStreamDecryptor_decrypt(
+            &ptr->dec,
+            Array_sliceBefore(ptr->recv_buf, received_size),
+            buffer
+        )
+    );
+
+    Return RESULT_VALUE(u, decrypted_size);
 }
 
 
 
-void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr, Socket sock, Array(u8) aes_key)
+void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr, 
+    Socket sock, u32 crypto_buffer_size, Array(u8) aes_key)
 {
     ptr->sock = sock;
     AESBlockEncryptor_construct(&ptr->enc, aes_key, AESBlockEncryptor_DEFAULT_CLASS);
     AESBlockDecryptor_construct(&ptr->dec, aes_key, AESBlockDecryptor_DEFAULT_CLASS);
+    ptr->recv_buf = Array_alloc_size(crypto_buffer_size);
+    ptr->send_buf = Array_alloc_size(crypto_buffer_size);
 }
 
-Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
+void EncryptedSocketUDP_destroy(EncryptedSocketUDP* ptr){
-    Array(u8) decrypted_buf, Array(u8) encrypted_buf,
+    socket_close(ptr->sock);
-    EndpointIPv4 remote_end)
+    free(ptr->recv_buf.data);
+    free(ptr->send_buf.data);
+}
+
+Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr, 
+    Array(u8) buffer, EndpointIPv4 remote_end)
 {
-    Deferral(4);
+    Deferral(1);
-    try(u32 encrypted_size, u, AESBlockEncryptor_encrypt(&ptr->enc, decrypted_buf, encrypted_buf));
+
-    encrypted_buf.size = encrypted_size;
+    try(u32 encrypted_size, u, 
-    try_void(socket_sendto(ptr->sock, encrypted_buf, remote_end));
+        AESBlockEncryptor_encrypt(
+            &ptr->enc,
+            buffer,
+            ptr->send_buf
+        )
+    );
+    try_void(
+        socket_sendto(
+            ptr->sock, 
+            Array_sliceBefore(ptr->send_buf, encrypted_size),
+            remote_end
+        )
+    );
+
     Return RESULT_VOID;
 }
 
 Result(i32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
-    Array(u8) encrypted_buf, Array(u8) decrypted_buf,
+    Array(u8) buffer, SocketRecvFlag flags, NULLABLE(EndpointIPv4*) remote_end)
-    SocketRecvFlag flags, NULLABLE(EndpointIPv4*) remote_end)
 {
-    Deferral(4);
+    Deferral(1);
-    try(i32 received_size, i, socket_recvfrom(ptr->sock, encrypted_buf, flags, remote_end));
+    
-    encrypted_buf.size = received_size;
+    // There is some metadata at the start of each AES block
-    try(i32 decrypted_size, u, AESBlockDecryptor_decrypt(&ptr->dec, encrypted_buf, decrypted_buf));
+    u32 size_to_receive = AESBlockEncryptor_calcDstSize(buffer.size);
-    Return RESULT_VALUE(i, decrypted_size);
+    try(i32 received_size, i,
+        socket_recvfrom(
+            ptr->sock,
+            Array_sliceBefore(ptr->recv_buf, size_to_receive),
+            flags,
+            remote_end
+        )
+    );
+    try(u32 decrypted_size, u,
+        AESBlockDecryptor_decrypt(
+            &ptr->dec,
+            Array_sliceBefore(ptr->recv_buf, received_size),
+            buffer
+        )
+    );
+
+    Return RESULT_VALUE(u, decrypted_size);
 }

src/network/encrypted_sockets.h

@@ -10,16 +10,21 @@ typedef struct EncryptedSocketTCP {
     Socket sock;
     AESStreamEncryptor enc;
     AESStreamDecryptor dec;
+    Array(u8) send_buf;
+    Array(u8) recv_buf;
 } EncryptedSocketTCP;
 
-void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr, Socket sock, Array(u8) aes_key);
+void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr, 
+    Socket sock, u32 crypto_buffer_size, Array(u8) aes_key);
 
-Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
+/// closes the socket
-    Array(u8) decrypted_buf, Array(u8) encrypted_buf);
+void EncryptedSocketTCP_destroy(EncryptedSocketTCP* ptr);
 
-Result(void) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
+Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr, 
-    Array(u8) encrypted_buf, Array(u8) decrypted_buf,
+    Array(u8) buffer);
-    SocketRecvFlag flags);
+
+Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr, 
+    Array(u8) buffer, SocketRecvFlag flags);
 
 
 //////////////////////////////////////////////////////////////////////////////
@@ -30,15 +35,18 @@ typedef struct EncryptedSocketUDP {
     Socket sock;
     AESBlockEncryptor enc;
     AESBlockDecryptor dec;
+    Array(u8) send_buf;
+    Array(u8) recv_buf;
 } EncryptedSocketUDP;
 
-void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr, Socket sock, Array(u8) aes_key);
+void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr, 
+    Socket sock, u32 crypto_buffer_size, Array(u8) aes_key);
 
-Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
+/// closes the socket
-    Array(u8) decrypted_buf, Array(u8) encrypted_buf,
+void EncryptedSocketUDP_destroy(EncryptedSocketUDP* ptr);
-    EndpointIPv4 remote_end);
 
-Result(i32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
+Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr, 
-    Array(u8) encrypted_buf, Array(u8) decrypted_buf,
+    Array(u8) buffer, EndpointIPv4 remote_end);
-    SocketRecvFlag flags,
+
-    NULLABLE(EndpointIPv4*) remote_end);
+Result(u32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
+    Array(u8) buffer, SocketRecvFlag flags, NULLABLE(EndpointIPv4*) remote_end);

src/network/socket.c

@@ -61,16 +61,24 @@ Result(void) socket_connect(Socket s, EndpointIPv4 remote_end){
 
 Result(void) socket_send(Socket s, Array(u8) buffer){
     i32 r = send(s, buffer.data, buffer.size, 0);
-    if(r < 0)
+    if(r < 0){
         return RESULT_ERROR_SOCKET();
+    }
+    if((u32)r != buffer.size){
+        return RESULT_ERROR_FMT("Socket was unable to send data");
+    }
     return RESULT_VOID;
 }
 
 Result(void) socket_sendto(Socket s, Array(u8) buffer, EndpointIPv4 dst){
     struct sockaddr_in sockaddr = EndpointIPv4_toSockaddr(dst);    
     i32 r = sendto(s, buffer.data, buffer.size, 0, (void*)&sockaddr, sizeof(sockaddr));
-    if(r < 0)
+    if(r < 0){
         return RESULT_ERROR_SOCKET();
+    }
+    if((u32)r != buffer.size){
+        return RESULT_ERROR_FMT("Socket was unable to send data");
+    }
     return RESULT_VOID;
 }
 
@@ -85,8 +93,13 @@ static inline int SocketRecvFlags_toStd(SocketRecvFlag flags){
 
 Result(i32) socket_recv(Socket s, Array(u8) buffer, SocketRecvFlag flags){
     i32 r = recv(s, buffer.data, buffer.size, SocketRecvFlags_toStd(flags));
-    if(r < 0)
+    if(r < 0){
         return RESULT_ERROR_SOCKET();
+    }
+    if(r == 0 || (flags & SocketRecvFlag_WaitAll && (u32)r != buffer.size))
+    {
+        return RESULT_ERROR("Socket closed", false);
+    }
     return RESULT_VALUE(i, r);
 }
 
@@ -95,9 +108,14 @@ Result(i32) socket_recvfrom(Socket s, Array(u8) buffer, SocketRecvFlag flags, NU
     i32 sockaddr_size = sizeof(remote_addr);
     i32 r = recvfrom(s, buffer.data, buffer.size, SocketRecvFlags_toStd(flags), 
         (struct sockaddr*)&remote_addr, (void*)&sockaddr_size);
-    if(r < 0)
+    if(r < 0){
         return RESULT_ERROR_SOCKET();
-    
+    }
+    if(r == 0 || (flags & SocketRecvFlag_WaitAll && (u32)r != buffer.size))
+    {
+        return RESULT_ERROR("Socket closed", false);
+    }
+
     //TODO: add IPV6 support (struct sockaddr_in6)
     assert(sockaddr_size == sizeof(remote_addr));
 

src/network/tcp-chat-protocol/v1.c

@@ -1,14 +1,9 @@
 #include "v1.h"
 
-Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, Array(u8) session_key){
+void ClientHandshake_construct(ClientHandshake* ptr, Array(u8) session_key){
-    Deferral(1);
+    memcpy(ptr->session_key, session_key.data, sizeof(ptr->session_key));
-    try_assert(session_key.size == AES_SESSION_KEY_SIZE);
-    PacketHeader_construct(&ptr->header, PROTOCOL_VERSION, PacketType_ClientHandshake, session_key.size);
-    memcpy(ptr->session_key, session_key.data, session_key.size);
-    Return RESULT_VOID;
 }
 
 void ServerHandshake_construct(ServerHandshake* ptr, u64 session_id){
-    PacketHeader_construct(&ptr->header, PROTOCOL_VERSION, PacketType_ServerHandshake, sizeof(session_id));
     ptr->session_id = session_id;
 }

src/network/tcp-chat-protocol/v1.h

@@ -3,7 +3,7 @@
 #include "network/tcp-chat-protocol/constant.h"
 
 #define PROTOCOL_VERSION 1 /* 1.0.0 */
-
+#define NETWORK_BUFFER_SIZE 65536
 
 typedef enum PacketType {
     PacketType_Invalid,
@@ -14,21 +14,18 @@ typedef enum PacketType {
 
 
 typedef struct ErrorMessage {
-    PacketHeader header;
     /* content stream of size `header.content_size` */
 } ErrorMessage;
 
 
 typedef struct ClientHandshake {
-    PacketHeader header;
     u8 session_key[AES_SESSION_KEY_SIZE];
 } ClientHandshake;
 
-Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, Array(u8) session_key);
+void ClientHandshake_construct(ClientHandshake* ptr, Array(u8) session_key);
 
 
 typedef struct ServerHandshake {
-    PacketHeader header;
     u64 session_id;
 } ServerHandshake;
 

src/server/ClientConnection.c

@@ -4,7 +4,7 @@
 void ClientConnection_close(ClientConnection* conn){
     if(conn == NULL)
         return;
-    socket_close(conn->sock.sock);
+    EncryptedSocketTCP_destroy(&conn->sock);
     free(conn->session_key.data);
     free(conn);
 }
@@ -26,19 +26,21 @@ Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_cred
     conn->session_id = session_id;
     conn->session_key = Array_alloc_size(AES_SESSION_KEY_SIZE);
 
-    Array(u8) enc_buf = Array_alloc_size(8*1024);
+    Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
-    Defer(free(enc_buf.data));
+    Defer(free(buffer.data));
-    Array(u8) dec_buf = Array_alloc_size(8*1024);
-    Defer(free(dec_buf.data));
-    u32 enc_size = 0, dec_size = 0;
     
     // TODO: set socket timeout to 5 seconds
 
     // receive message encrypted by server public key
-    try(enc_size, u, 
+    u32 header_and_message_size = sizeof(PacketHeader) + sizeof(ClientHandshake);
+    Array(u8) bufferPart_encryptedClientHandshake = {
+        .data = (u8*)buffer.data + header_and_message_size,
+        .size = server_credentials->rsa_pk.nlen
+    };
+    try_void( 
         socket_recv(
             sock_tcp,
-            Array_sliceBefore(enc_buf, server_credentials->rsa_pk.nlen),
+            bufferPart_encryptedClientHandshake,
             SocketRecvFlag_WaitAll
         )
     );
@@ -46,42 +48,47 @@ Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_cred
     // decrypt the message using server private key
     RSADecryptor rsa_dec;
     RSADecryptor_construct(&rsa_dec, &server_credentials->rsa_sk);
-    try(dec_size, u, 
+    try(u32 rsa_dec_size, u, 
         RSADecryptor_decrypt(
             &rsa_dec,
-            Array_sliceBefore(enc_buf, enc_size),
+            bufferPart_encryptedClientHandshake,
-            dec_buf
+            buffer
         )
     );
     
     // validate client handshake
-    if(dec_size != sizeof(ClientHandshake)){
+    if(rsa_dec_size != header_and_message_size){
         Return RESULT_ERROR_FMT(
             "decrypted message (size: %u) is not a ClientHandshake (size: %u)",
-            dec_size, (u32)sizeof(ClientHandshake) 
+            rsa_dec_size, header_and_message_size 
         );
     }
-    ClientHandshake* client_handshake = dec_buf.data;
+    PacketHeader* packet_header = buffer.data;
-    try_void(PacketHeader_validateMagic(&client_handshake->header));
+    ClientHandshake* client_handshake = Array_sliceAfter(buffer, sizeof(PacketHeader)).data;
-    if(client_handshake->header.type != PacketType_ClientHandshake){
+    try_void(PacketHeader_validateMagic(packet_header));
+    if(packet_header->type != PacketType_ClientHandshake){
         Return RESULT_ERROR_FMT(
             "received message of unexpected type: %u",
-            client_handshake->header.type
+            packet_header->type
         );
     }
 
     // use received session key
     memcpy(conn->session_key.data, client_handshake->session_key, conn->session_key.size);
-    EncryptedSocketTCP_construct(&conn->sock, sock_tcp, conn->session_key);
+    EncryptedSocketTCP_construct(&conn->sock, sock_tcp, NETWORK_BUFFER_SIZE, conn->session_key);
     
-    // construct ServerHandshake in dec_buf
+    // construct PacketHeader and ServerHandshake in buffer
-    ServerHandshake_construct((ServerHandshake*)dec_buf.data, session_id);
+    PacketHeader_construct(buffer.data, PROTOCOL_VERSION,
+        PacketType_ServerHandshake, sizeof(ServerHandshake));
+    ServerHandshake_construct(
+        Array_sliceAfter(buffer, sizeof(PacketHeader)).data,
+        session_id);
     // send ServerHandshake over encrypted TCP socket
+    header_and_message_size = sizeof(PacketHeader) + sizeof(ServerHandshake);
     try_void(
         EncryptedSocketTCP_send(
             &conn->sock,
-            Array_sliceBefore(dec_buf, sizeof(ServerHandshake)),
+            Array_sliceBefore(buffer, header_and_message_size)
-            enc_buf
         )
     );
 

src/server/server.c

@@ -4,6 +4,7 @@
 #include "server.h"
 #include "config.h"
 #include "log.h"
+#include "network/tcp-chat-protocol/v1.h"
 
 typedef struct ConnectionHandlerArgs {
     Socket accepted_socket;
@@ -88,7 +89,10 @@ static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_
     Defer(free(args));
     
     ClientConnection* conn = NULL;
-    Defer(ClientConnection_close(conn));
+    Defer(
+        ClientConnection_close(conn);
+        logInfo(log_ctx, "session closed");
+    );
     // establish encrypted connection
     try(conn, p, 
         ClientConnection_accept(
@@ -98,10 +102,16 @@ static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_
             args->session_id
         )
     );
-    logDebug(log_ctx, "session accepted");
+    logInfo(log_ctx, "session accepted");
 
     // handle requests
+    
+    // Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
+    // Defer(free(buffer.data));
+    // u32 dec_size = 0;
+
     while(true){
+        
         sleepMsec(10);
     }