Timerix/tcp-chat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Timerix:ea4a649e00bf8f46dd9834158fc8e0f531d1dd48
Branches Tags
Timerix:main
..
compare: Timerix:ee522ac40115f4c31900857b1fae968aab7b889e
Branches Tags
Timerix:main

No commits in common. "ea4a649e00bf8f46dd9834158fc8e0f531d1dd48" and "ee522ac40115f4c31900857b1fae968aab7b889e" have entirely different histories.
ea4a649e00 ... ee522ac401

21 changed files with 207 additions and 644 deletions
Show Stats Expand all files Collapse all files

2
dependencies/tlibc vendored

@ -1 +1 @@
Subproject commit d6436d08338a0a762e727f0c816dd5a09782b180
Subproject commit 00a1a29d342c6b3bcb8015a661364e10a3134fe4

70
src/client/ServerConnection.c
View File

@ -63,27 +63,49 @@ Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_creden
// connect to server address
try(Socket _s, i, socket_open_TCP());
try_void(socket_TCP_enableAliveChecks_default(_s));
// TODO: set socket timeout to 5 seconds
try_void(socket_connect(_s, conn->server_end));
EncryptedSocketTCP_construct(&conn->sock, _s, NETWORK_BUFFER_SIZE, conn->session_key);
// send PacketHeader and ClientHandshake
// encryption by server public key
PacketHeader packet_header = {0};
ClientHandshake client_handshake = {0};
try_void(ClientHandshake_tryConstruct(&client_handshake, &packet_header,
conn->session_key));
try_void(EncryptedSocketTCP_sendStructRSA(&conn->sock, &conn->rsa_enc, &packet_header));
try_void(EncryptedSocketTCP_sendStructRSA(&conn->sock, &conn->rsa_enc, &client_handshake));
Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
// fix for valgrind false detected errors about uninitialized memory
Array_memset(buffer, 0xCC);
Defer(free(buffer.data));
// construct PacketHeader and ClientHandshake in buffer
PacketHeader_construct(buffer.data, PROTOCOL_VERSION,
PacketType_ClientHandshake, sizeof(ClientHandshake));
ClientHandshake_construct(
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,
Array_sliceBefore(buffer, header_and_message_size),
bufferPart_encryptedClientHandshake
)
);
bufferPart_encryptedClientHandshake.size = rsa_enc_size;
// send encrypted message
try_void(socket_send(conn->sock.sock, bufferPart_encryptedClientHandshake));
// receive server response
try_void(EncryptedSocketTCP_recvStruct(&conn->sock, &packet_header));
try_void(PacketHeader_validateMagic(&packet_header));
try_void(
EncryptedSocketTCP_recv(&conn->sock,
Array_sliceBefore(buffer, sizeof(PacketHeader)),
SocketRecvFlag_WaitAll
)
);
PacketHeader* packet_header = buffer.data;
try_void(PacketHeader_validateMagic(packet_header));
// handle server response
switch(packet_header.type){
switch(packet_header->type){
case PacketType_ErrorMessage: {
u32 err_msg_size = packet_header.content_size;
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);
@ -97,8 +119,8 @@ Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_creden
try_void(
EncryptedSocketTCP_recv(
&conn->sock,
Array_sliceTo(err_buf, err_msg_size),
SocketRecvFlag_WholeBuffer
Array_sliceBefore(err_buf, err_msg_size),
SocketRecvFlag_WaitAll
)
);
@ -107,13 +129,23 @@ Result(ServerConnection*) ServerConnection_open(ClientCredentials* client_creden
Return RESULT_ERROR((char*)err_buf.data, true);
}
case PacketType_ServerHandshake: {
ServerHandshake server_handshake;
try_void(EncryptedSocketTCP_recvStruct(&conn->sock, &server_handshake));
conn->session_id = server_handshake.session_id;
Array(u8) bufferPart_ServerHandshake = {
.data = (u8*)buffer.data + sizeof(PacketHeader),
.size = sizeof(ServerHandshake)
};
try_void(
EncryptedSocketTCP_recv(
&conn->sock,
bufferPart_ServerHandshake,
SocketRecvFlag_WaitAll
)
);
ServerHandshake* server_handshake = bufferPart_ServerHandshake.data;
conn->session_id = server_handshake->session_id;
break;
}
default:
Return RESULT_ERROR_FMT("unexpected response type: %i", packet_header.type);
Return RESULT_ERROR_FMT("unexpected response type: %i", packet_header->type);
}
success = true;

36
src/client/client.c
View File

@ -1,7 +1,5 @@
#include "client.h"
#include "term.h"
#include "tlibc/time.h"
#include "network/tcp-chat-protocol/v1.h"
static const str greeting_art = STR(
" ^,,^ ╱|\n"
@ -25,22 +23,21 @@ static Result(void) commandExec(str command, bool* stop);
static Result(void) askUserNameAndPassword(ClientCredentials** cred){
Deferral(8);
char username_buf[128];
str username = str_null;
char username_buf[1024];
str usrername = str_null;
while(true) {
printf("username: ");
if(fgets(username_buf, sizeof(username_buf), stdin) == NULL){
Return RESULT_ERROR("STDIN is closed", false);
}
username = str_from_cstr(username_buf);
if(username.size < USERNAME_SIZE_MIN || username.size > USERNAME_SIZE_MAX){
printf("ERROR: username length (in bytes) must be >= %i and <= %i\n",
USERNAME_SIZE_MIN, USERNAME_SIZE_MAX);
usrername = str_from_cstr(username_buf);
if(usrername.size < 4){
printf("ERROR: username length must be at least 4\n");
}
else break;
}
char password_buf[128];
char password_buf[1024];
str password = str_null;
while(true) {
printf("password: ");
@ -49,14 +46,13 @@ static Result(void) askUserNameAndPassword(ClientCredentials** cred){
Return RESULT_ERROR("STDIN is closed", false);
}
password = str_from_cstr(password_buf);
if(password.size < PASSWORD_SIZE_MIN || password.size > PASSWORD_SIZE_MAX){
printf("ERROR: password length (in bytes) must be >= %i and <= %i\n",
PASSWORD_SIZE_MIN, PASSWORD_SIZE_MAX);
if(password.size < 8){
printf("ERROR: password length must be at least 8\n");
}
else break;
}
try(*cred, p, ClientCredentials_create(username, password));
try(*cred, p, ClientCredentials_create(usrername, password));
Return RESULT_VOID;
}
@ -90,7 +86,7 @@ Result(void) client_run() {
if(command_input.size == 0)
continue;
ResultVar(void) com_result = commandExec(command_input, &stop);
Result(void) com_result = commandExec(command_input, &stop);
if(com_result.error){
str e_str = Error_toStr(com_result.error);
printf("%s\n", e_str.data);
@ -142,21 +138,11 @@ static Result(void) commandExec(str command, bool* stop){
// TODO: request server info
// show server info
// save server info to user's db
// try log in
// request log in
// if not registered, request registration and then log in
// call serverConnection_run():
// function with infinite loop which sends and receives messages
// with navigation across server channels
//
}
else if(is_alias("c") || is_alias("connect")){
// TODO: read saved servers from database
// show scrollable list of them
// select one
// try log in
// if not registered, ask user if they want to register
// regiser and then log in
}
else {
Return RESULT_ERROR_FMT("unknown kommand: '%s'\n"

72
src/cryptography/AES.c
View File

@ -4,23 +4,18 @@
// write data from src to array and increment array data pointer
static inline void __Array_writeNext(Array(u8)* dst, u8* src, size_t size){
memcpy(dst->data, src, size);
*dst = Array_sliceFrom(*dst, size);
*dst = Array_sliceAfter(*dst, size);
}
// read data from array to dst and increment array data pointer
static inline void __Array_readNext(u8* dst, Array(u8)* src, size_t size){
memcpy(dst, src->data, size);
*src = Array_sliceFrom(*src, size);
*src = Array_sliceAfter(*src, size);
}
//////////////////////////////////////////////////////////////////////////////
// AESBlockEncryptor //
//////////////////////////////////////////////////////////////////////////////
void AESBlockEncryptor_construct(AESBlockEncryptor* ptr,
Array(u8) key, const br_block_cbcenc_class* enc_class)
{
void AESBlockEncryptor_construct(AESBlockEncryptor* ptr, Array(u8) key, const br_block_cbcenc_class* enc_class){
assert(key.size == 16 || key.size == 24 || key.size == 32);
ptr->enc_class = enc_class;
@ -30,15 +25,7 @@ void AESBlockEncryptor_construct(AESBlockEncryptor* ptr,
rng_init_sha256_seedFromSystem(&ptr->rng_ctx.vtable);
}
void AESBlockEncryptor_changeKey(AESBlockEncryptor* ptr, Array(u8) key)
{
assert(key.size == 16 || key.size == 24 || key.size == 32);
ptr->enc_class->init((void*)ptr->enc_keys, key.data, key.size);
}
Result(u32) AESBlockEncryptor_encrypt(AESBlockEncryptor* ptr,
Array(u8) src, Array(u8) dst)
{
Result(u32) AESBlockEncryptor_encrypt(AESBlockEncryptor* ptr, Array(u8) src, Array(u8) dst){
Deferral(4);
u32 encrypted_size = AESBlockEncryptor_calcDstSize(src.size);
try_assert(dst.size >= encrypted_size);
@ -80,28 +67,15 @@ Result(u32) AESBlockEncryptor_encrypt(AESBlockEncryptor* ptr,
}
//////////////////////////////////////////////////////////////////////////////
// AESBlockDecryptor //
//////////////////////////////////////////////////////////////////////////////
void AESBlockDecryptor_construct(AESBlockDecryptor* ptr,
Array(u8) key, const br_block_cbcdec_class* dec_class)
{
void AESBlockDecryptor_construct(AESBlockDecryptor* ptr, Array(u8) key, const br_block_cbcdec_class* dec_class){
assert(key.size == 16 || key.size == 24 || key.size == 32);
ptr->dec_class = dec_class;
ptr->dec_class->init((void*)ptr->dec_keys, key.data, key.size);
}
void AESBlockDecryptor_changeKey(AESBlockDecryptor* ptr, Array(u8) key)
{
assert(key.size == 16 || key.size == 24 || key.size == 32);
ptr->dec_class->init((void*)ptr->dec_keys, key.data, key.size);
}
Result(u32) AESBlockDecryptor_decrypt(AESBlockDecryptor* ptr,
Array(u8) src, Array(u8) dst)
{
Result(u32) AESBlockDecryptor_decrypt(AESBlockDecryptor* ptr, Array(u8) src, Array(u8) dst){
Deferral(4);
try_assert(src.size >= AESBlockEncryptor_calcDstSize(0));
try_assert(src.size % 16 == 0 && "src must be array of 16-byte blocks");
@ -142,13 +116,8 @@ Result(u32) AESBlockDecryptor_decrypt(AESBlockDecryptor* ptr,
}
//////////////////////////////////////////////////////////////////////////////
// AESStreamEncryptor //
//////////////////////////////////////////////////////////////////////////////
void AESStreamEncryptor_construct(AESStreamEncryptor* ptr,
Array(u8) key, const br_block_ctr_class* ctr_class)
{
void AESStreamEncryptor_construct(AESStreamEncryptor* ptr, Array(u8) key, const br_block_ctr_class* ctr_class){
assert(key.size == 16 || key.size == 24 || key.size == 32);
ptr->ctr_class = ctr_class;
@ -162,15 +131,7 @@ void AESStreamEncryptor_construct(AESStreamEncryptor* ptr,
ptr->block_counter = 0;
}
void AESStreamEncryptor_changeKey(AESStreamEncryptor* ptr, Array(u8) key)
{
assert(key.size == 16 || key.size == 24 || key.size == 32);
ptr->ctr_class->init((void*)ptr->ctr_keys, key.data, key.size);
}
Result(u32) AESStreamEncryptor_encrypt(AESStreamEncryptor* ptr,
Array(u8) src, Array(u8) dst)
{
Result(u32) AESStreamEncryptor_encrypt(AESStreamEncryptor* ptr, Array(u8) src, Array(u8) dst){
Deferral(4);
u32 encrypted_size = AESStreamEncryptor_calcDstSize(src.size);
try_assert(dst.size >= encrypted_size);
@ -203,13 +164,8 @@ Result(u32) AESStreamEncryptor_encrypt(AESStreamEncryptor* ptr,
}
//////////////////////////////////////////////////////////////////////////////
// AESStreamDecryptor //
//////////////////////////////////////////////////////////////////////////////
void AESStreamDecryptor_construct(AESStreamDecryptor* ptr,
Array(u8) key, const br_block_ctr_class* ctr_class)
{
void AESStreamDecryptor_construct(AESStreamDecryptor* ptr, Array(u8) key, const br_block_ctr_class* ctr_class){
assert(key.size == 16 || key.size == 24 || key.size == 32);
ptr->ctr_class = ctr_class;
@ -218,15 +174,7 @@ void AESStreamDecryptor_construct(AESStreamDecryptor* ptr,
ptr->block_counter = 0;
}
void AESStreamDecryptor_changeKey(AESStreamDecryptor* ptr, Array(u8) key)
{
assert(key.size == 16 || key.size == 24 || key.size == 32);
ptr->ctr_class->init((void*)ptr->ctr_keys, key.data, key.size);
}
Result(u32) AESStreamDecryptor_decrypt(AESStreamDecryptor* ptr,
Array(u8) src, Array(u8) dst)
{
Result(u32) AESStreamDecryptor_decrypt(AESStreamDecryptor* ptr, Array(u8) src, Array(u8) dst){
Deferral(4);
// if it is the beginning of the stream, read IV

14
src/cryptography/AES.h
View File

@ -18,7 +18,7 @@
//TODO: use PKS#7 instead of this garbage
typedef struct EncryptedBlockHeader {
u8 padding_size;
} ATTRIBUTE_ALIGNED(16) EncryptedBlockHeader;
} __attribute__((aligned(16))) EncryptedBlockHeader;
//////////////////////////////////////////////////////////////////////////////
// AESBlockEncryptor //
@ -40,9 +40,6 @@ typedef struct AESBlockEncryptor {
/// @param enc_class &br_aes_XXX_cbcenc_vtable
void AESBlockEncryptor_construct(AESBlockEncryptor* ptr, Array(u8) key, const br_block_cbcenc_class* enc_class);
/// @param key supported sizes: 16, 24, 32
void AESBlockEncryptor_changeKey(AESBlockEncryptor* ptr, Array(u8) key);
/// @brief Encrypts a complete message. For part-by-part encryption use AESStreamEncryptor.
/// @param src array of any size
/// @param dst array of size >= AESBlockEncryptor_calcDstSize(src.size)
@ -66,9 +63,6 @@ typedef struct AESBlockDecryptor {
/// @param dec_class &br_aes_XXX_cbcdec_vtable
void AESBlockDecryptor_construct(AESBlockDecryptor* ptr, Array(u8) key, const br_block_cbcdec_class* dec_class);
/// @param key supported sizes: 16, 24, 32
void AESBlockDecryptor_changeKey(AESBlockDecryptor* ptr, Array(u8) key);
/// @brief Decrypts a complete message. For part-by-part decryption use AESStreamEncryptor.
/// @param src array of size at least AESBlockEncryptor_calcDstSize(0). Size must be multiple of 16.
/// @param dst array of size >= src.size
@ -94,9 +88,6 @@ typedef struct AESStreamEncryptor {
/// @param dec_class &br_aes_XXX_ctr_vtable
void AESStreamEncryptor_construct(AESStreamEncryptor* ptr, Array(u8) key, const br_block_ctr_class* ctr_class);
/// @param key supported sizes: 16, 24, 32
void AESStreamEncryptor_changeKey(AESStreamEncryptor* ptr, Array(u8) key);
/// use this only at the beginning of the stream
#define AESStreamEncryptor_calcDstSize(src_size) (src_size + __AES_STREAM_IV_SIZE)
@ -123,9 +114,6 @@ typedef struct AESStreamDecryptor {
/// @param dec_class &br_aes_XXX_ctr_vtable
void AESStreamDecryptor_construct(AESStreamDecryptor* ptr, Array(u8) key, const br_block_ctr_class* ctr_class);
/// @param key supported sizes: 16, 24, 32
void AESStreamDecryptor_changeKey(AESStreamDecryptor* ptr, Array(u8) key);
/// @brief Reads IV from `src`, then decrypts data and writes it to dst
/// @param src array of any size
/// @param dst array of size >= src.size

32
src/cryptography/RSA.c
View File

@ -175,11 +175,6 @@ Result(void) RSA_parsePrivateKey_base64(cstr src, br_rsa_private_key* sk){
Return RESULT_VOID;
}
//////////////////////////////////////////////////////////////////////////////
// RSAEncryptor //
//////////////////////////////////////////////////////////////////////////////
void RSAEncryptor_construct(RSAEncryptor* ptr, const br_rsa_public_key* pk){
ptr->pk = pk;
ptr->rng.vtable = &br_hmac_drbg_vtable;
@ -190,11 +185,11 @@ Result(u32) RSAEncryptor_encrypt(RSAEncryptor* ptr, Array(u8) src, Array(u8) dst
u32 key_size_bytes = ptr->pk->nlen;
const u32 max_src_size = RSAEncryptor_calcMaxSrcSize(key_size_bytes * 8, 256);
if(src.size > max_src_size){
return RESULT_ERROR_FMT("src.size (%u) must be <= RSAEncryptor_calcMaxSrcSize() (%u)",
return RESULT_ERROR_FMT("src.size (%u) must be <= %u (use RSAEncryptor_calcMaxSrcSize)",
src.size, max_src_size);
}
if(dst.size < key_size_bytes){
return RESULT_ERROR_FMT("dst.size (%u) must be >= key length in bytes (%u)",
return RESULT_ERROR_FMT("dst.size (%u) must be >= %u (key length in bytes)",
dst.size, key_size_bytes);
}
size_t sz = br_rsa_i31_oaep_encrypt(
@ -211,27 +206,30 @@ Result(u32) RSAEncryptor_encrypt(RSAEncryptor* ptr, Array(u8) src, Array(u8) dst
}
//////////////////////////////////////////////////////////////////////////////
// RSADecryptor //
//////////////////////////////////////////////////////////////////////////////
void RSADecryptor_construct(RSADecryptor* ptr, const br_rsa_private_key* sk){
ptr->sk = sk;
}
Result(u32) RSADecryptor_decrypt(RSADecryptor* ptr, Array(u8) buffer){
Result(u32) RSADecryptor_decrypt(RSADecryptor* ptr, Array(u8) src, Array(u8) dst){
u32 key_size_bits = ptr->sk->n_bitlen;
if(buffer.size != key_size_bits/8){
return RESULT_ERROR_FMT("buffer.size (%u) must be == key length in bytes (%u)",
buffer.size, key_size_bits/8);
if(src.size != key_size_bits/8){
return RESULT_ERROR_FMT("src.size (%u) must be == %u (key length in bytes)",
src.size, key_size_bits/8);
}
size_t sz = buffer.size;
const u32 max_src_size = RSAEncryptor_calcMaxSrcSize(key_size_bits, 256);
if(dst.size < max_src_size){
return RESULT_ERROR_FMT("dst.size (%u) must be >= %u (use RSAEncryptor_calcMaxSrcSize)",
dst.size, max_src_size);
}
memcpy(dst.data, src.data, src.size);
size_t sz = src.size;
size_t r = br_rsa_i31_oaep_decrypt(
&br_sha256_vtable,
NULL, 0,
ptr->sk,
buffer.data, &sz);
dst.data, &sz);
if(r == 0){
return RESULT_ERROR("RSA encryption failed", false);

5
src/cryptography/RSA.h
View File

@ -58,7 +58,6 @@ str RSA_serializePublicKey_base64(const br_rsa_public_key* sk);
/// @param sk out public key. WARNING: .p is allocated on heap
Result(void) RSA_parsePublicKey_base64(cstr src, br_rsa_public_key* sk);
//////////////////////////////////////////////////////////////////////////////
// RSAEncryptor //
//////////////////////////////////////////////////////////////////////////////
@ -91,7 +90,6 @@ https://crypto.stackexchange.com/a/42100
/// @return size of encrypted data
Result(u32) RSAEncryptor_encrypt(RSAEncryptor* ptr, Array(u8) src, Array(u8) dst);
//////////////////////////////////////////////////////////////////////////////
// RSADecryptor //
//////////////////////////////////////////////////////////////////////////////
@ -104,5 +102,6 @@ typedef struct RSADecryptor {
void RSADecryptor_construct(RSADecryptor* ptr, const br_rsa_private_key* sk);
/// @param src buffer with size == key size in bytes
/// @param dst buffer with size >= `RSAEncryptor_calcMaxSrcSize(key_size_bits, 256)`
/// @return size of decrypted data
Result(u32) RSADecryptor_decrypt(RSADecryptor* ptr, Array(u8) buffer);
Result(u32) RSADecryptor_decrypt(RSADecryptor* ptr, Array(u8) src, Array(u8) dst);

10
src/db/idb.c
View File

@ -9,7 +9,7 @@ typedef struct TableFileHeader {
u16 version;
bool _dirty_bit;
u32 row_size;
} ATTRIBUTE_ALIGNED(256) TableFileHeader;
} __attribute__((aligned(256))) TableFileHeader;
typedef struct Table {
TableFileHeader header;
@ -133,7 +133,7 @@ Result(void) Table_validateHeader(Table* t){
Result(void) Table_validateRowSize(Table* t, u32 row_size){
if(row_size != t->header.row_size){
ResultVar(void) error_result = RESULT_ERROR_FMT(
Result(void) error_result = RESULT_ERROR_FMT(
"Requested row size (%u) doesn't match saved row size (%u)",
row_size, t->header.row_size);
return error_result;
@ -226,7 +226,7 @@ Result(Table*) idb_getOrCreateTable(IncrementalDB* db, str _table_name, u32 row_
}
if(!HashMap_tryPush(&db->tables_map, t->name, &t)){
ResultVar(void) error_result = RESULT_ERROR_FMT(
Result(void) error_result = RESULT_ERROR_FMT(
"Table '%s' is already open",
t->name.data);
Return error_result;
@ -273,7 +273,7 @@ Result(void) idb_updateRows(Table* t, u64 id, const void* src, u64 count){
}
try_void(Table_setDirtyBit(t, true));
Defer(IGNORE_RESULT Table_setDirtyBit(t, false));
Defer(Table_setDirtyBit(t, false));
i64 file_pos = sizeof(t->header) + id * t->header.row_size;
@ -295,7 +295,7 @@ Result(u64) idb_pushRows(Table* t, const void* src, u64 count){
Defer(pthread_mutex_unlock(&t->mutex));
try_void(Table_setDirtyBit(t, true));
Defer(IGNORE_RESULT Table_setDirtyBit(t, false));
Defer(Table_setDirtyBit(t, false));
const u64 new_row_index = t->row_count;

99
src/network/encrypted_sockets.c
View File

@ -1,9 +1,5 @@
#include "encrypted_sockets.h"
//////////////////////////////////////////////////////////////////////////////
// EncryptedSocketTCP //
//////////////////////////////////////////////////////////////////////////////
void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr,
Socket sock, u32 crypto_buffer_size, Array(u8) aes_key)
{
@ -20,11 +16,6 @@ void EncryptedSocketTCP_destroy(EncryptedSocketTCP* ptr){
free(ptr->send_buf.data);
}
void EncryptedSocketTCP_changeKey(EncryptedSocketTCP* ptr, Array(u8) aes_key){
AESStreamEncryptor_changeKey(&ptr->enc, aes_key);
AESStreamDecryptor_changeKey(&ptr->dec, aes_key);
}
Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
Array(u8) buffer)
{
@ -40,7 +31,7 @@ Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
try_void(
socket_send(
ptr->sock,
Array_sliceTo(ptr->send_buf, encrypted_size)
Array_sliceBefore(ptr->send_buf, encrypted_size)
)
);
@ -60,14 +51,14 @@ Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
try(i32 received_size, i,
socket_recv(
ptr->sock,
Array_sliceTo(ptr->recv_buf, size_to_receive),
Array_sliceBefore(ptr->recv_buf, size_to_receive),
flags
)
);
try(u32 decrypted_size, u,
AESStreamDecryptor_decrypt(
&ptr->dec,
Array_sliceTo(ptr->recv_buf, received_size),
Array_sliceBefore(ptr->recv_buf, received_size),
buffer
)
);
@ -75,80 +66,7 @@ Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
Return RESULT_VALUE(u, decrypted_size);
}
Result(void) EncryptedSocketTCP_sendRSA(EncryptedSocketTCP* ptr,
RSAEncryptor* rsa_enc, Array(u8) buffer)
{
Deferral(1);
try(u32 encrypted_size, u,
RSAEncryptor_encrypt(
rsa_enc,
buffer,
ptr->send_buf
)
);
try_void(
socket_send(
ptr->sock,
Array_sliceTo(ptr->send_buf, encrypted_size)
)
);
Return RESULT_VOID;
}
Result(u32) EncryptedSocketTCP_recvRSA(EncryptedSocketTCP* ptr,
RSADecryptor* rsa_dec, Array(u8) buffer, SocketRecvFlag flags)
{
Deferral(1);
// RSA encrypts message in block of size KEY_SIZE_BYTES.
// SocketRecvFlag_WholeBuffer should be always enabled to receive such blocks.
// If this flag is set in `flags` by caller, it means decrypted message size
// must be the same as buffer size.
bool fill_whole_buffer = (flags & SocketRecvFlag_WholeBuffer) != 0;
flags |= SocketRecvFlag_WholeBuffer;
u32 size_to_receive = rsa_dec->sk->n_bitlen / 8;
try(i32 received_size, i,
socket_recv(
ptr->sock,
Array_sliceTo(ptr->recv_buf, size_to_receive),
flags
)
);
try(u32 decrypted_size, u,
RSADecryptor_decrypt(
rsa_dec,
Array_sliceTo(ptr->recv_buf, received_size)
)
);
if(fill_whole_buffer){
if(decrypted_size != buffer.size){
Return RESULT_ERROR_FMT(
"SocketRecvFlag_WholeBuffer is set, "
"but decrypted_size (%u) != buffer.size (%u)",
decrypted_size, buffer.size
);
}
}
else if(decrypted_size > buffer.size){
Return RESULT_ERROR_FMT(
"decrypted_size (%u) > buffer.size (%u)",
decrypted_size, buffer.size
);
}
memcpy(buffer.data, ptr->recv_buf.data, decrypted_size);
Return RESULT_VALUE(u, decrypted_size);
}
//////////////////////////////////////////////////////////////////////////////
// EncryptedSocketUDP //
//////////////////////////////////////////////////////////////////////////////
void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr,
Socket sock, u32 crypto_buffer_size, Array(u8) aes_key)
@ -166,11 +84,6 @@ void EncryptedSocketUDP_destroy(EncryptedSocketUDP* ptr){
free(ptr->send_buf.data);
}
void EncryptedSocketUDP_changeKey(EncryptedSocketUDP* ptr, Array(u8) aes_key){
AESBlockEncryptor_changeKey(&ptr->enc, aes_key);
AESBlockDecryptor_changeKey(&ptr->dec, aes_key);
}
Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
Array(u8) buffer, EndpointIPv4 remote_end)
{
@ -186,7 +99,7 @@ Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
try_void(
socket_sendto(
ptr->sock,
Array_sliceTo(ptr->send_buf, encrypted_size),
Array_sliceBefore(ptr->send_buf, encrypted_size),
remote_end
)
);
@ -204,7 +117,7 @@ Result(i32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
try(i32 received_size, i,
socket_recvfrom(
ptr->sock,
Array_sliceTo(ptr->recv_buf, size_to_receive),
Array_sliceBefore(ptr->recv_buf, size_to_receive),
flags,
remote_end
)
@ -212,7 +125,7 @@ Result(i32) EncryptedSocketUDP_recvfrom(EncryptedSocketUDP* ptr,
try(u32 decrypted_size, u,
AESBlockDecryptor_decrypt(
&ptr->dec,
Array_sliceTo(ptr->recv_buf, received_size),
Array_sliceBefore(ptr->recv_buf, received_size),
buffer
)
);

28
src/network/encrypted_sockets.h
View File

@ -1,7 +1,6 @@
#pragma once
#include "network/socket.h"
#include "cryptography/AES.h"
#include "cryptography/RSA.h"
//////////////////////////////////////////////////////////////////////////////
// EncryptedSocketTCP //
@ -21,37 +20,12 @@ void EncryptedSocketTCP_construct(EncryptedSocketTCP* ptr,
/// closes the socket
void EncryptedSocketTCP_destroy(EncryptedSocketTCP* ptr);
void EncryptedSocketTCP_changeKey(EncryptedSocketTCP* ptr, Array(u8) aes_key);
Result(void) EncryptedSocketTCP_send(EncryptedSocketTCP* ptr,
Array(u8) buffer);
#define EncryptedSocketTCP_sendStruct(socket, structPtr)\
EncryptedSocketTCP_send(socket,\
Array_construct_size(structPtr, sizeof(*structPtr)))
Result(u32) EncryptedSocketTCP_recv(EncryptedSocketTCP* ptr,
Array(u8) buffer, SocketRecvFlag flags);
#define EncryptedSocketTCP_recvStruct(socket, structPtr)\
EncryptedSocketTCP_recv(socket,\
Array_construct_size(structPtr, sizeof(*structPtr)),\
SocketRecvFlag_WholeBuffer)
Result(void) EncryptedSocketTCP_sendRSA(EncryptedSocketTCP* ptr,
RSAEncryptor* rsa_enc, Array(u8) buffer);
#define EncryptedSocketTCP_sendStructRSA(socket, rsa_enc, structPtr)\
EncryptedSocketTCP_sendRSA(socket, rsa_enc,\
Array_construct_size(structPtr, sizeof(*structPtr)))
Result(u32) EncryptedSocketTCP_recvRSA(EncryptedSocketTCP* ptr,
RSADecryptor* rsa_dec, Array(u8) buffer, SocketRecvFlag flags);
#define EncryptedSocketTCP_recvStructRSA(socket, rsa_dec, structPtr)\
EncryptedSocketTCP_recvRSA(socket, rsa_dec,\
Array_construct_size(structPtr, sizeof(*structPtr)),\
SocketRecvFlag_WholeBuffer)
//////////////////////////////////////////////////////////////////////////////
// EncryptedSocketUDP //
@ -71,8 +45,6 @@ void EncryptedSocketUDP_construct(EncryptedSocketUDP* ptr,
/// closes the socket
void EncryptedSocketUDP_destroy(EncryptedSocketUDP* ptr);
void EncryptedSocketUDP_changeKey(EncryptedSocketUDP* ptr, Array(u8) aes_key);
Result(void) EncryptedSocketUDP_sendto(EncryptedSocketUDP* ptr,
Array(u8) buffer, EndpointIPv4 remote_end);

13
src/network/internal.h
View File

@ -10,29 +10,20 @@
#endif
#endif
// include OS-dependent socket headers
#if KN_USE_WINSOCK
#include <winsock2.h>
#include <ws2ipdef.h>
// There you can see what error codes mean.
#include <winerror.h>
#define RESULT_ERROR_SOCKET() RESULT_ERROR(sprintf_malloc(64, "Winsock error %i", WSAGetLastError()), true)
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#endif
#if KN_USE_WINSOCK
#define RESULT_ERROR_SOCKET()\
RESULT_ERROR(sprintf_malloc(64, "Winsock error %i (look in <winerror.h>)", WSAGetLastError()), true);
#else
#define RESULT_ERROR_SOCKET()\
RESULT_ERROR(strerror(errno), false);
#define RESULT_ERROR_SOCKET() RESULT_ERROR(strerror(errno), false)
#endif
struct sockaddr_in EndpointIPv4_toSockaddr(EndpointIPv4 end);

8
src/network/network.c
View File

@ -13,9 +13,13 @@ Result(void) network_init(){
return RESULT_VOID;
}
void network_deinit(){
Result(void) network_deinit(){
#if _WIN32
// Deinitialize Winsock
(void)WSACleanup();
int result = WSACleanup();
if (result != 0) {
return RESULT_ERROR_FMT("WSACleanup failed with error code 0x%X", result);
}
#endif
return RESULT_VOID;
}

2
src/network/network.h
View File

@ -2,4 +2,4 @@
#include "tlibc/errors.h"
Result(void) network_init();
void network_deinit();
Result(void) network_deinit();

75
src/network/socket.c
View File

@ -3,7 +3,7 @@
#include <assert.h>
Result(Socket) socket_open_TCP(){
Socket s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
Socket s = socket(AF_INET, SOCK_STREAM, 0);
if(s == -1){
return RESULT_ERROR_SOCKET();
}
@ -20,7 +20,7 @@ void socket_close(Socket s){
}
Result(void) socket_shutdown(Socket s, SocketShutdownType direction){
if(shutdown(s, (int)direction) != 0)
if(shutdown(s, (int)direction) == -1)
return RESULT_ERROR_SOCKET();
return RESULT_VOID;
}
@ -38,18 +38,18 @@ Result(void) socket_listen(Socket s, i32 backlog){
return RESULT_VOID;
}
Result(Socket) socket_accept(Socket listening_sock, NULLABLE(EndpointIPv4*) remote_end) {
Result(Socket) socket_accept(Socket main_socket, NULLABLE(EndpointIPv4*) remote_end) {
struct sockaddr_in remote_addr = {0};
i32 sockaddr_size = sizeof(remote_addr);
Socket accepted_sock = accept(listening_sock, (void*)&remote_addr, (void*)&sockaddr_size);
if(accepted_sock == -1)
Socket user_connection = accept(main_socket, (void*)&remote_addr, (void*)&sockaddr_size);
if(user_connection == -1)
return RESULT_ERROR_SOCKET();
//TODO: add IPV6 support (struct sockaddr_in6)
assert(sockaddr_size == sizeof(remote_addr));
if(remote_end)
*remote_end = EndpointIPv4_fromSockaddr(remote_addr);
return RESULT_VALUE(i, accepted_sock);
return RESULT_VALUE(i, user_connection);
}
Result(void) socket_connect(Socket s, EndpointIPv4 remote_end){
@ -86,7 +86,7 @@ static inline int SocketRecvFlags_toStd(SocketRecvFlag flags){
int f = 0;
if (flags & SocketRecvFlag_Peek)
f |= MSG_PEEK;
if (flags & SocketRecvFlag_WholeBuffer)
if (flags & SocketRecvFlag_WaitAll)
f |= MSG_WAITALL;
return f;
}
@ -96,7 +96,7 @@ Result(i32) socket_recv(Socket s, Array(u8) buffer, SocketRecvFlag flags){
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if(r == 0 || (flags & SocketRecvFlag_WholeBuffer && (u32)r != buffer.size))
if(r == 0 || (flags & SocketRecvFlag_WaitAll && (u32)r != buffer.size))
{
return RESULT_ERROR("Socket closed", false);
}
@ -111,7 +111,7 @@ Result(i32) socket_recvfrom(Socket s, Array(u8) buffer, SocketRecvFlag flags, NU
if(r < 0){
return RESULT_ERROR_SOCKET();
}
if(r == 0 || (flags & SocketRecvFlag_WholeBuffer && (u32)r != buffer.size))
if(r == 0 || (flags & SocketRecvFlag_WaitAll && (u32)r != buffer.size))
{
return RESULT_ERROR("Socket closed", false);
}
@ -123,60 +123,3 @@ Result(i32) socket_recvfrom(Socket s, Array(u8) buffer, SocketRecvFlag flags, NU
*remote_end = EndpointIPv4_fromSockaddr(remote_addr);
return RESULT_VALUE(i, r);
}
#define try_setsockopt(socket, level, OPT){ \
if(setsockopt(socket, level, OPT, (void*)&opt_##OPT, sizeof(opt_##OPT)) != 0)\
return RESULT_ERROR_SOCKET();\
}
Result(void) socket_TCP_enableAliveChecks(Socket s,
sec_t first_check_time, u32 checks_count, sec_t checks_interval)
{
#if KN_USE_WINSOCK
BOOL opt_SO_KEEPALIVE = 1; // enable keepalives
DWORD opt_TCP_KEEPIDLE = first_check_time;
DWORD opt_TCP_KEEPCNT = checks_count;
DWORD opt_TCP_KEEPINTVL = checks_interval;
try_setsockopt(s, SOL_SOCKET, SO_KEEPALIVE);
try_setsockopt(s, IPPROTO_TCP, TCP_KEEPIDLE);
try_setsockopt(s, IPPROTO_TCP, TCP_KEEPCNT);
try_setsockopt(s, IPPROTO_TCP, TCP_KEEPINTVL);
// timeout for connect()
DWORD opt_TCP_MAXRT = checks_count * checks_interval;
try_setsockopt(s, IPPROTO_TCP, TCP_MAXRT);
#else
int opt_SO_KEEPALIVE = 1; // enable keepalives
int opt_TCP_KEEPIDLE = first_check_time;
int opt_TCP_KEEPCNT = checks_count;
int opt_TCP_KEEPINTVL = checks_interval;
try_setsockopt(s, SOL_SOCKET, SO_KEEPALIVE);
try_setsockopt(s, IPPROTO_TCP, TCP_KEEPIDLE);
try_setsockopt(s, IPPROTO_TCP, TCP_KEEPCNT);
try_setsockopt(s, IPPROTO_TCP, TCP_KEEPINTVL);
// read more in the article
int opt_TCP_USER_TIMEOUT = checks_count * checks_interval * 1000;
try_setsockopt(s, IPPROTO_TCP, TCP_USER_TIMEOUT);
#endif
return RESULT_VOID;
}
Result(void) socket_setTimeout(Socket s, u32 ms){
#if KN_USE_WINSOCK
DWORD opt_SO_SNDTIMEO = ms;
DWORD opt_SO_RCVTIMEO = opt_SO_SNDTIMEO;
#else
struct timeval opt_SO_SNDTIMEO = {
.tv_sec = ms/1000,
.tv_usec = (ms%1000)*1000
};
struct timeval opt_SO_RCVTIMEO = opt_SO_SNDTIMEO;
#endif
try_setsockopt(s, SOL_SOCKET, SO_SNDTIMEO);
try_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO);
return RESULT_VOID;
}

23
src/network/socket.h
View File

@ -1,8 +1,8 @@
#pragma once
#include "endpoint.h"
#include "tlibc/errors.h"
#include "tlibc/time.h"
#include "tlibc/collections/Array.h"
#include "tlibc/time.h"
typedef enum SocketShutdownType {
SocketShutdownType_Receive = 0,
@ -13,7 +13,7 @@ typedef enum SocketShutdownType {
typedef enum SocketRecvFlag {
SocketRecvFlag_None = 0,
SocketRecvFlag_Peek = 0b1 /* next recv call will read the same data */,
SocketRecvFlag_WholeBuffer = 0b10 /* waits until buffer is full */,
SocketRecvFlag_WaitAll = 0b10 /* waits until buffer is full */,
} SocketRecvFlag;
typedef i64 Socket;
@ -21,28 +21,11 @@ typedef i64 Socket;
Result(Socket) socket_open_TCP();
void socket_close(Socket s);
Result(void) socket_shutdown(Socket s, SocketShutdownType direction);
Result(void) socket_bind(Socket s, EndpointIPv4 local_end);
Result(void) socket_listen(Socket s, i32 backlog);
Result(Socket) socket_accept(Socket listening_sock, NULLABLE(EndpointIPv4*) remote_end);
Result(Socket) socket_accept(Socket s, NULLABLE(EndpointIPv4*) remote_end);
Result(void) socket_connect(Socket s, EndpointIPv4 remote_end);
Result(void) socket_send(Socket s, Array(u8) buffer);
Result(void) socket_sendto(Socket s, Array(u8) buffer, EndpointIPv4 dst);
Result(i32) socket_recv(Socket s, Array(u8) buffer, SocketRecvFlag flags);
Result(i32) socket_recvfrom(Socket s, Array(u8) buffer, SocketRecvFlag flags, NULLABLE(EndpointIPv4*) remote_end);
/// Enables sending SO_KEEPALIVE packets when socket is idling.
/// Also enables TCP_USER_TIMEOUT to handle situations
/// when socket is not sending KEEPALIVE packets.
/// Read more: https://blog.cloudflare.com/when-tcp-sockets-refuse-to-die/
/// RU translaton: https://habr.com/ru/articles/700470/
Result(void) socket_TCP_enableAliveChecks(Socket s,
sec_t first_check_time, u32 checks_count, sec_t checks_interval);
#define socket_TCP_enableAliveChecks_default(socket) \
socket_TCP_enableAliveChecks(socket, 1, 4, 5)
#define SOCKET_TIMEOUT_MS_DEFAULT 5000
#define SOCKET_TIMEOUT_MS_INFINITE 0
/// @brief sets general timeout for send() and recv()
Result(void) socket_setTimeout(Socket s, u32 ms);

19
src/network/tcp-chat-protocol/constant.c
View File

@ -9,25 +9,6 @@ Result(void) PacketHeader_validateMagic(PacketHeader* ptr){
return RESULT_VOID;
}
Result(void) PacketHeader_validateType(PacketHeader* ptr, u16 expected_type){
if(ptr->type != expected_type){
return RESULT_ERROR_FMT(
"expected message of type %u, but received of type %u",
expected_type, ptr->type);
}
return RESULT_VOID;
}
Result(void) PacketHeader_validateContentSize(PacketHeader* ptr, u64 expected_size){
if(ptr->content_size != expected_size){
return RESULT_ERROR_FMT(
"expected message with content_size " IFWIN("%llu", "%lu")
", but received with content_size " IFWIN("%llu", "%lu"),
expected_size, ptr->content_size);
}
return RESULT_VOID;
}
void PacketHeader_construct(PacketHeader* ptr, u8 protocol_version, u16 type, u64 content_size){
ptr->magic.n = PacketHeader_MAGIC.n;
ptr->protocol_version = protocol_version;

4
src/network/tcp-chat-protocol/constant.h
View File

@ -14,9 +14,7 @@ typedef struct PacketHeader {
u16 type;
u32 _reserved4;
u64 content_size;
} ATTRIBUTE_ALIGNED(64) PacketHeader;
} __attribute__((aligned(64))) PacketHeader;
void PacketHeader_construct(PacketHeader* ptr, u8 protocol_version, u16 type, u64 content_size);
Result(void) PacketHeader_validateMagic(PacketHeader* ptr);
Result(void) PacketHeader_validateType(PacketHeader* ptr, u16 expected_type);
Result(void) PacketHeader_validateContentSize(PacketHeader* ptr, u64 expected_size);

70
src/network/tcp-chat-protocol/v1.c
View File

@ -1,73 +1,9 @@
#include "v1.h"
#define _PacketHeader_construct(T) \
PacketHeader_construct(header, PROTOCOL_VERSION, PacketType_##T, sizeof(T))
Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, PacketHeader* header,
Array(u8) session_key)
{
Deferral(1);
_PacketHeader_construct(ClientHandshake);
try_assert(session_key.size == sizeof(ptr->session_key));
memcpy(ptr->session_key, session_key.data, session_key.size);
Return RESULT_VOID;
void ClientHandshake_construct(ClientHandshake* ptr, Array(u8) session_key){
memcpy(ptr->session_key, session_key.data, sizeof(ptr->session_key));
}
void ServerHandshake_construct(ServerHandshake* ptr, PacketHeader* header,
u64 session_id)
{
_PacketHeader_construct(ServerHandshake);
void ServerHandshake_construct(ServerHandshake* ptr, u64 session_id){
ptr->session_id = session_id;
}
void ServerPublicInfoRequest_construct(ServerPublicInfoRequest *ptr, PacketHeader* header,
ServerPublicInfo property)
{
_PacketHeader_construct(ServerPublicInfoRequest);
ptr->property = property;
}
Result(void) LoginRequest_tryConstruct(LoginRequest *ptr, PacketHeader* header,
Array(u8) token)
{
Deferral(1);
_PacketHeader_construct(LoginRequest);
try_assert(token.size == sizeof(ptr->token));
memcpy(ptr->token, token.data, token.size);
Return RESULT_VOID;
}
void LoginResponse_construct(LoginResponse* ptr, PacketHeader* header,
u64 user_id, u64 landing_channel_id)
{
_PacketHeader_construct(LoginResponse);
ptr->user_id = user_id;
ptr->landing_channel_id = landing_channel_id;
}
Result(void) RegisterRequest_tryConstruct(RegisterRequest *ptr, PacketHeader* header,
str username, Array(u8) token)
{
Deferral(1);
_PacketHeader_construct(RegisterRequest);
try_assert(username.size >= USERNAME_SIZE_MIN && username.size <= USERNAME_SIZE_MAX);
ptr->username_size = username.size;
memcpy(ptr->username, username.data, username.size);
try_assert(token.size == sizeof(ptr->token));
memcpy(ptr->token, token.data, token.size);
Return RESULT_VOID;
}
void RegisterResponse_construct(RegisterResponse *ptr, PacketHeader* header,
u64 user_id)
{
_PacketHeader_construct(RegisterResponse);
ptr->user_id = user_id;
}

89
src/network/tcp-chat-protocol/v1.h
View File

@ -1,105 +1,32 @@
#pragma once
#include "tlibc/errors.h"
#include "tlibc/string/str.h"
#include "network/tcp-chat-protocol/constant.h"
#include "cryptography/cryptography.h"
#define PROTOCOL_VERSION 1 /* 1.0.0 */
#define NETWORK_BUFFER_SIZE 65536
#define ALIGN_PACKET_STRUCT ATTRIBUTE_ALIGNED(8)
typedef enum PacketType {
PacketType_Invalid,
PacketType_ErrorMessage,
PacketType_ClientHandshake,
PacketType_ServerHandshake,
PacketType_ServerPublicInfoRequest,
PacketType_ServerPublicInfoResponse,
PacketType_LoginRequest,
PacketType_LoginResponse,
PacketType_RegisterRequest,
PacketType_RegisterResponse,
} ATTRIBUTE_PACKED PacketType;
} __attribute__((__packed__)) PacketType;
// typedef struct ErrorMessage {
// /* stream of size header.content_size */
// } ErrorMessage;
typedef struct ErrorMessage {
/* content stream of size `header.content_size` */
} ErrorMessage;
typedef struct ClientHandshake {
u8 session_key[AES_SESSION_KEY_SIZE];
} ALIGN_PACKET_STRUCT ClientHandshake;
} ClientHandshake;
Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, PacketHeader* header,
Array(u8) session_key);
void ClientHandshake_construct(ClientHandshake* ptr, Array(u8) session_key);
typedef struct ServerHandshake {
u64 session_id;
} ALIGN_PACKET_STRUCT ServerHandshake;
void ServerHandshake_construct(ServerHandshake* ptr, PacketHeader* header,
u64 session_id);
typedef enum ServerPublicInfo {
ServerPublicInfo_Name,
ServerPublicInfo_Description,
} ATTRIBUTE_PACKED ServerPublicInfo;
typedef struct ServerPublicInfoRequest {
u32 property;
} ALIGN_PACKET_STRUCT ServerPublicInfoRequest;
void ServerPublicInfoRequest_construct(ServerPublicInfoRequest* ptr, PacketHeader* header,
ServerPublicInfo property);
// typedef struct ServerPublicInfoResponse {
// /* stream of size header.content_size */
// } ServerPublicInfoResponse;
typedef struct LoginRequest {
u8 token[PASSWORD_HASH_SIZE];
} ALIGN_PACKET_STRUCT LoginRequest;
Result(void) LoginRequest_tryConstruct(LoginRequest* ptr, PacketHeader* header,
Array(u8) token);
typedef struct LoginResponse {
u64 user_id;
u64 landing_channel_id;
} ALIGN_PACKET_STRUCT LoginResponse;
void LoginResponse_construct(LoginResponse* ptr, PacketHeader* header,
u64 user_id, u64 landing_channel_id);
#define USERNAME_SIZE_MIN 4
#define USERNAME_SIZE_MAX 64
#define PASSWORD_SIZE_MIN 8
#define PASSWORD_SIZE_MAX 32
typedef struct RegisterRequest {
u32 username_size;
char username[USERNAME_SIZE_MAX];
u8 token[PASSWORD_HASH_SIZE];
} ALIGN_PACKET_STRUCT RegisterRequest;
Result(void) RegisterRequest_tryConstruct(RegisterRequest* ptr, PacketHeader* header,
str username, Array(u8) token);
typedef struct RegisterResponse {
u64 user_id;
} ALIGN_PACKET_STRUCT RegisterResponse;
void RegisterResponse_construct(RegisterResponse* ptr, PacketHeader* header,
u64 user_id);
} ServerHandshake;
void ServerHandshake_construct(ServerHandshake* ptr, u64 session_id);

84
src/server/ClientConnection.c
View File

@ -25,36 +25,74 @@ Result(ClientConnection*) ClientConnection_accept(ServerCredentials* server_cred
conn->client_end = client_end;
conn->session_id = session_id;
conn->session_key = Array_alloc_size(AES_SESSION_KEY_SIZE);
// correct session key will be received from client later
Array_memset(conn->session_key, 0);
EncryptedSocketTCP_construct(&conn->sock, sock_tcp, NETWORK_BUFFER_SIZE, conn->session_key);
try_void(socket_TCP_enableAliveChecks_default(sock_tcp));
Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
// fix for valgrind false detected errors about uninitialized memory
Array_memset(buffer, 0xCC);
Defer(free(buffer.data));
// decrypt the rsa messages using server private key
// TODO: set socket timeout to 5 seconds
// receive message encrypted by server public key
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,
bufferPart_encryptedClientHandshake,
SocketRecvFlag_WaitAll
)
);
// decrypt the message using server private key
RSADecryptor rsa_dec;
RSADecryptor_construct(&rsa_dec, &server_credentials->rsa_sk);
// receive PacketHeader
PacketHeader packet_header = {0};
try_void(EncryptedSocketTCP_recvStructRSA(&conn->sock, &rsa_dec, &packet_header));
try_void(PacketHeader_validateMagic(&packet_header));
try_void(PacketHeader_validateType(&packet_header, PacketType_ClientHandshake));
try_void(PacketHeader_validateContentSize(&packet_header, sizeof(ClientHandshake)));
// receive ClientHandshake
ClientHandshake client_handshake = {0};
try_void(EncryptedSocketTCP_recvStructRSA(&conn->sock, &rsa_dec, &client_handshake));
try(u32 rsa_dec_size, u,
RSADecryptor_decrypt(
&rsa_dec,
bufferPart_encryptedClientHandshake,
buffer
)
);
// validate client handshake
if(rsa_dec_size != header_and_message_size){
Return RESULT_ERROR_FMT(
"decrypted message (size: %u) is not a ClientHandshake (size: %u)",
rsa_dec_size, header_and_message_size
);
}
PacketHeader* packet_header = buffer.data;
ClientHandshake* client_handshake = Array_sliceAfter(buffer, sizeof(PacketHeader)).data;
try_void(PacketHeader_validateMagic(packet_header));
if(packet_header->type != PacketType_ClientHandshake){
Return RESULT_ERROR_FMT(
"received message of unexpected type: %u",
packet_header->type
);
}
// use received session key
memcpy(conn->session_key.data, client_handshake.session_key, conn->session_key.size);
EncryptedSocketTCP_changeKey(&conn->sock, conn->session_key);
memcpy(conn->session_key.data, client_handshake->session_key, conn->session_key.size);
EncryptedSocketTCP_construct(&conn->sock, sock_tcp, NETWORK_BUFFER_SIZE, conn->session_key);
// send PacketHeader and ServerHandshake over encrypted TCP socket
ServerHandshake server_handshake = {0};
ServerHandshake_construct(&server_handshake, &packet_header,
// construct PacketHeader and ServerHandshake in buffer
PacketHeader_construct(buffer.data, PROTOCOL_VERSION,
PacketType_ServerHandshake, sizeof(ServerHandshake));
ServerHandshake_construct(
Array_sliceAfter(buffer, sizeof(PacketHeader)).data,
session_id);
try_void(EncryptedSocketTCP_sendStruct(&conn->sock, &packet_header));
try_void(EncryptedSocketTCP_sendStruct(&conn->sock, &server_handshake));
// send ServerHandshake over encrypted TCP socket
header_and_message_size = sizeof(PacketHeader) + sizeof(ServerHandshake);
try_void(
EncryptedSocketTCP_send(
&conn->sock,
Array_sliceBefore(buffer, header_and_message_size)
)
);
success = true;
Return RESULT_VALUE(p, conn);

96
src/server/server.c
View File

@ -1,6 +1,5 @@
#include <pthread.h>
#include "tlibc/filesystem.h"
#include "tlibc/time.h"
#include "db/idb.h"
#include "server.h"
#include "config.h"
@ -58,7 +57,7 @@ Result(void) server_run(cstr server_endpoint_cstr, cstr config_path){
logDebug(log_ctx, "initializing main socket");
EndpointIPv4 server_end;
try_void(EndpointIPv4_parse(server_endpoint_cstr, &server_end));
EndpointIPv4_parse(server_endpoint_cstr, &server_end);
try(Socket main_socket, i, socket_open_TCP());
try_void(socket_bind(main_socket, server_end));
try_void(socket_listen(main_socket, 512));
@ -73,7 +72,7 @@ Result(void) server_run(cstr server_endpoint_cstr, cstr config_path){
//TODO: use async IO instead of threads to not waste system resources
// while waiting for incoming data in 100500 threads
try_stderrcode(pthread_create(&conn_thread, NULL, handle_connection, args));
try_stderrcode(pthread_detach(conn_thread));
try_stderrcode(pthread_detach(&conn_thread));
}
Return RESULT_VOID;
@ -84,7 +83,7 @@ static void* handle_connection(void* _args){
char log_ctx[64];
sprintf(log_ctx, "Session-" IFWIN("%llx", "%lx"), args->session_id);
ResultVar(void) r = try_handle_connection(args, log_ctx);
Result(void) r = try_handle_connection(args, log_ctx);
if(r.error){
str error_s = Error_toStr(r.error);
logError(log_ctx, "%s", error_s.data);
@ -114,89 +113,16 @@ static Result(void) try_handle_connection(ConnectionHandlerArgs* args, cstr log_
);
logInfo(log_ctx, "session accepted");
// handle unauthorized requests
bool ahtorized = false;
PacketHeader req_header = {0};
PacketHeader res_header = {0};
while(!ahtorized){
sleepMsec(50);
//TODO: implement some additional check if socket is dead or not
// handle requests
Array(u8) buffer = Array_alloc_size(NETWORK_BUFFER_SIZE);
// fix for valgrind false detected errors about uninitialized memory
Array_memset(buffer, 0xCC);
Defer(free(buffer.data));
u32 dec_size = 0;
try_void(EncryptedSocketTCP_recvStruct(&conn->sock, &req_header));
try_void(PacketHeader_validateMagic(&req_header));
//TODO: move request handlers to separate functions
switch(req_header.type){
default:{
Array(u8) err_buf = Array_alloc(u8, 128);
bool err_complete = false;
Defer(if(!err_complete) free(err_buf.data));
sprintf(err_buf.data, "Received unexpected packet of type %u",
req_header.type);
err_buf.size = strlen(err_buf.data);
PacketHeader_construct(&res_header,
PROTOCOL_VERSION, PacketType_ErrorMessage, err_buf.size);
try_void(EncryptedSocketTCP_sendStruct(&conn->sock, &res_header));
//TODO: limit ErrorMessage size to fit into EncryptedSocketTCP.internal_buffer_size
try_void(EncryptedSocketTCP_send(&conn->sock, err_buf));
err_complete = true;
Return RESULT_ERROR(err_buf.data, true);
}
case PacketType_ServerPublicInfoRequest:{
ServerPublicInfoRequest req = {0};
try_void(PacketHeader_validateContentSize(&req_header, sizeof(req)));
try_void(EncryptedSocketTCP_recvStruct(&conn->sock, &req));
//TODO: try find requested info
Array(u8) content;
PacketHeader_construct(&res_header,
PROTOCOL_VERSION, PacketType_ServerPublicInfoResponse, content.size);
try_void(EncryptedSocketTCP_sendStruct(&conn->sock, &res_header));
try_void(EncryptedSocketTCP_send(&conn->sock, content));
break;
}
case PacketType_LoginRequest:{
LoginRequest req = {0};
try_void(PacketHeader_validateContentSize(&req_header, sizeof(req)));
try_void(EncryptedSocketTCP_recvStruct(&conn->sock, &req));
//TODO: try authorize client
u64 user_id;
u64 landing_channel_id;
LoginResponse res = {0};
LoginResponse_construct(&res, &res_header, user_id, landing_channel_id);
try_void(EncryptedSocketTCP_sendStruct(&conn->sock, &res_header));
try_void(EncryptedSocketTCP_sendStruct(&conn->sock, &res));
ahtorized = true;
logInfo(log_ctx, "client authorized");
break;
}
case PacketType_RegisterRequest:{
RegisterRequest req = {0};
try_void(PacketHeader_validateContentSize(&req_header, sizeof(req)));
try_void(EncryptedSocketTCP_recvStruct(&conn->sock, &req));
//TODO: try register client
u64 user_id;
RegisterResponse res = {0};
RegisterResponse_construct(&res, &res_header, user_id);
try_void(EncryptedSocketTCP_sendStruct(&conn->sock, &res_header));
try_void(EncryptedSocketTCP_sendStruct(&conn->sock, &res));
break;
}
}
}
// handle authorized requests
while(true){
sleepMsec(50);
sleepMsec(10);
}
Return RESULT_VOID;