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

moved program modes code to separate files

Browse Source
This commit is contained in:
Timerix 2025-11-18 16:27:54 +05:00
parent 1b00f503c8
commit d0d7d26671
8 changed files with 223 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
src/cli/main.c
View File

@ -1,43 +1,13 @@
#include "tlibc/tlibc.h"
#include "tlibc/base64.h"
#include "tlibc/filesystem.h"
#include "tlibc/time.h"
#include "network/network.h"
#include "cli/ClientCLI/ClientCLI.h"
#include "server/server_internal.h"
#include "cryptography/RSA.h"
#include "modes/modes.h"
#define _DEFAULT_CONFIG_PATH_CLIENT "tcp-chat-client.config"
#define _DEFAULT_CONFIG_PATH_SERVER "tcp-chat-server.config"
#define arg_is(LITERAL) str_equals(arg_str, STR(LITERAL))
typedef enum ProgramMode {
ClientMode,
ServerMode,
RsaGenStdin,
RsaGenRandom,
RandomBytes,
RandomBytesBase64,
} ProgramMode;
static void log_func(void* logger, LogSeverity severity, cstr context, cstr msg){
(void)logger;
cstr severity_cstr;
switch(severity){
default: severity_cstr = "INVALID_LOG_SEVERITY"; break;
case LogSeverity_Debug: severity_cstr = "DBUG"; break;
case LogSeverity_Info: severity_cstr = "INFO"; break;
case LogSeverity_Warn: severity_cstr = "WARN"; break;
case LogSeverity_Error: severity_cstr = "ERRR"; break;
}
DateTime dt;
DateTime_getLocal(&dt);
printf("[" FMT_DateTime_text "][%s/%s]: %s\n", DT_expand(dt), context, severity_cstr, msg);
}
int main(const int argc, cstr const* argv){
Deferral(32);
@ -158,140 +128,31 @@ int main(const int argc, cstr const* argv){
}
switch(mode){
case ClientMode: {
if(!config_path)
config_path = _DEFAULT_CONFIG_PATH_CLIENT;
ClientCLI client;
ClientCLI_construct(&client);
Defer(ClientCLI_destroy(&client));
try_fatal_void(ClientCLI_run(&client));
break;
}
case ServerMode: {
if(!config_path)
config_path = _DEFAULT_CONFIG_PATH_SERVER;
// open file
try_fatal(FILE* config_file, p, file_open(config_path, FO_ReadExisting));
Defer(file_close(config_file));
// read whole file into str
Array(u8) config_buf = Array_null;
try_fatal_void(file_readWhole(config_file, &config_buf));
Defer(Array_free(config_buf));
str config_str = Array_castTo_str(config_buf, false);
config_buf.data = NULL;
// init server
try_fatal(Server* server, p, Server_create(config_str, NULL, log_func));
Defer(Server_free(server));
// manually close file and free config_buf
file_close(config_file);
config_file = NULL;
Array_free(config_buf);
// start infinite loop on main thread
try_fatal_void(Server_run(server));
break;
}
case RsaGenStdin: {
printfe("reading stdin...\n");
Array(u8) input_buf = Array_alloc_size(64*1024);
Defer(Array_free(input_buf));
br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
br_hmac_drbg_init(&rng, &br_sha256_vtable, NULL, 0);
i64 read_n = 0;
do {
read_n = fread(input_buf.data, 1, input_buf.size, stdin);
if(read_n < 0){
printfe("ERROR: no input\n");
Return 1;
}
// put bytes to rng as seed
br_hmac_drbg_update(&rng, input_buf.data, read_n);
} while(read_n == input_buf.size);
printfe("generating RSA key pair based on stdin...\n");
br_rsa_private_key sk;
br_rsa_public_key pk;
try_fatal_void(RSA_generateKeyPair(size_arg, &sk, &pk, &rng.vtable));
Defer(
RSA_destroyPrivateKey(&sk);
RSA_destroyPublicKey(&pk);
);
str sk_str = RSA_serializePrivateKey_base64(&sk);
printf("rsa_private_key = %s\n", sk_str.data);
str_free(sk_str);
str pk_str = RSA_serializePublicKey_base64(&pk);
printf("\nrsa_public_key = %s\n", pk_str.data);
str_free(pk_str);
break;
}
case RsaGenRandom: {
printfe("generating random RSA key pair...\n");
br_rsa_private_key sk;
br_rsa_public_key pk;
try_fatal_void(RSA_generateKeyPairFromSystemRandom(size_arg, &sk, &pk));
Defer(
RSA_destroyPrivateKey(&sk);
RSA_destroyPublicKey(&pk);
);
str sk_str = RSA_serializePrivateKey_base64(&sk);
printf("rsa_private_key = %s\n", sk_str.data);
str_free(sk_str);
str pk_str = RSA_serializePublicKey_base64(&pk);
printf("\nrsa_public_key = %s\n", pk_str.data);
str_free(pk_str);
break;
}
case RandomBytes: {
printfe("generating random bytes...\n");
br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
rng_init_sha256_seedFromSystem(&rng.vtable);
Array(u8) random_buf = Array_alloc_size(1024);
u32 full_buffers_n = size_arg / random_buf.size;
u32 remaining_n = size_arg % random_buf.size;
while(full_buffers_n > 0){
full_buffers_n--;
br_hmac_drbg_generate(&rng, random_buf.data, random_buf.size);
fwrite(random_buf.data, 1, random_buf.size, stdout);
}
br_hmac_drbg_generate(&rng, random_buf.data, remaining_n);
fwrite(random_buf.data, 1, remaining_n, stdout);
break;
}
case RandomBytesBase64: {
printfe("generating random bytes...\n");
br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
rng_init_sha256_seedFromSystem(&rng.vtable);
Array(u8) random_buf = Array_alloc_size(1024);
Array(u8) base64_buf = Array_alloc_size(base64_encodedSize(random_buf.size));
u32 full_buffers_n = size_arg / random_buf.size;
u32 remaining_n = size_arg % random_buf.size;
u32 enc_size = 0;
while(full_buffers_n > 0){
full_buffers_n--;
br_hmac_drbg_generate(&rng, random_buf.data, random_buf.size);
enc_size = base64_encode(random_buf.data, random_buf.size, base64_buf.data);
fwrite(base64_buf.data, 1, enc_size, stdout);
}
br_hmac_drbg_generate(&rng, random_buf.data, remaining_n);
enc_size = base64_encode(random_buf.data, remaining_n, base64_buf.data);
fwrite(base64_buf.data, 1, enc_size, stdout);
break;
}
default:
printfe("ERROR: invalid program mode %i\n", mode);
Return 1;
case ClientMode:
if(!config_path)
config_path = _DEFAULT_CONFIG_PATH_CLIENT;
try_fatal_void(run_ClientMode(config_path));
break;
case ServerMode:
if(!config_path)
config_path = _DEFAULT_CONFIG_PATH_SERVER;
try_fatal_void(run_ServerMode(config_path));
break;
case RsaGenStdin:
try_fatal_void(run_RsaGenStdin(size_arg));
break;
case RsaGenRandom:
try_fatal_void(run_RsaGenRandom(size_arg));
break;
case RandomBytes:
try_fatal_void(run_RandomBytes(size_arg));
break;
case RandomBytesBase64:
try_fatal_void(run_RandomBytesBase64(size_arg));
break;
}
Return 0;

15
src/cli/modes/ClientMode.c Normal file
View File

@ -0,0 +1,15 @@
#include "modes.h"
#include "cli/ClientCLI/ClientCLI.h"
Result(void) run_ClientMode(cstr config_path) {
Deferral(4);
(void)config_path;
ClientCLI client;
ClientCLI_construct(&client);
Defer(ClientCLI_destroy(&client));
// start infinite loop on main thread
try_fatal_void(ClientCLI_run(&client));
Return RESULT_VOID;
}

49
src/cli/modes/RandomBytes.c Normal file
View File

@ -0,0 +1,49 @@
#include "modes.h"
#include "cryptography/cryptography.h"
#include "tlibc/base64.h"
Result(void) run_RandomBytes(u32 key_size) {
Deferral(4);
printfe("generating random bytes...\n");
br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
rng_init_sha256_seedFromSystem(&rng.vtable);
Array(u8) random_buf = Array_alloc_size(1024);
u32 full_buffers_n = key_size / random_buf.size;
u32 remaining_n = key_size % random_buf.size;
while(full_buffers_n > 0){
full_buffers_n--;
br_hmac_drbg_generate(&rng, random_buf.data, random_buf.size);
fwrite(random_buf.data, 1, random_buf.size, stdout);
}
br_hmac_drbg_generate(&rng, random_buf.data, remaining_n);
fwrite(random_buf.data, 1, remaining_n, stdout);
Return RESULT_VOID;
}
Result(void) run_RandomBytesBase64(u32 key_size) {
Deferral(4);
printfe("generating random bytes...\n");
br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
rng_init_sha256_seedFromSystem(&rng.vtable);
Array(u8) random_buf = Array_alloc_size(1024);
Array(u8) base64_buf = Array_alloc_size(base64_encodedSize(random_buf.size));
u32 full_buffers_n = key_size / random_buf.size;
u32 remaining_n = key_size % random_buf.size;
u32 enc_size = 0;
while(full_buffers_n > 0){
full_buffers_n--;
br_hmac_drbg_generate(&rng, random_buf.data, random_buf.size);
enc_size = base64_encode(random_buf.data, random_buf.size, base64_buf.data);
fwrite(base64_buf.data, 1, enc_size, stdout);
}
br_hmac_drbg_generate(&rng, random_buf.data, remaining_n);
enc_size = base64_encode(random_buf.data, remaining_n, base64_buf.data);
fwrite(base64_buf.data, 1, enc_size, stdout);
Return RESULT_VOID;
}

64
src/cli/modes/RsaGen.c Normal file
View File

@ -0,0 +1,64 @@
#include "modes.h"
#include "cryptography/RSA.h"
Result(void) run_RsaGenStdin(u32 key_size) {
Deferral(4);
printfe("reading stdin...\n");
Array(u8) input_buf = Array_alloc_size(64*1024);
Defer(Array_free(input_buf));
br_hmac_drbg_context rng = { .vtable = &br_hmac_drbg_vtable };
br_hmac_drbg_init(&rng, &br_sha256_vtable, NULL, 0);
i64 read_n = 0;
do {
read_n = fread(input_buf.data, 1, input_buf.size, stdin);
if(read_n < 0){
Return RESULT_ERROR("ERROR: can't read stdin", false);
}
// put bytes to rng as seed
br_hmac_drbg_update(&rng, input_buf.data, read_n);
} while(read_n == input_buf.size);
printfe("generating RSA key pair based on stdin...\n");
br_rsa_private_key sk;
br_rsa_public_key pk;
try_void(RSA_generateKeyPair(key_size, &sk, &pk, &rng.vtable));
Defer(
RSA_destroyPrivateKey(&sk);
RSA_destroyPublicKey(&pk);
);
str sk_str = RSA_serializePrivateKey_base64(&sk);
printf("rsa_private_key = %s\n", sk_str.data);
str_free(sk_str);
str pk_str = RSA_serializePublicKey_base64(&pk);
printf("\nrsa_public_key = %s\n", pk_str.data);
str_free(pk_str);
Return RESULT_VOID;
}
Result(void) run_RsaGenRandom(u32 key_size) {
Deferral(4);
printfe("generating random RSA key pair...\n");
br_rsa_private_key sk;
br_rsa_public_key pk;
try_void(RSA_generateKeyPairFromSystemRandom(key_size, &sk, &pk));
Defer(
RSA_destroyPrivateKey(&sk);
RSA_destroyPublicKey(&pk);
);
str sk_str = RSA_serializePrivateKey_base64(&sk);
printf("rsa_private_key = %s\n", sk_str.data);
str_free(sk_str);
str pk_str = RSA_serializePublicKey_base64(&pk);
printf("\nrsa_public_key = %s\n", pk_str.data);
str_free(pk_str);
Return RESULT_VOID;
}

51
src/cli/modes/ServerMode.c Normal file
View File

@ -0,0 +1,51 @@
#include "modes.h"
#include "tcp-chat/server.h"
#include "tlibc/time.h"
static void log_func(void* logger, LogSeverity severity, cstr context, cstr msg){
(void)logger;
cstr severity_cstr;
switch(severity){
default: severity_cstr = "INVALID_LOG_SEVERITY"; break;
case LogSeverity_Debug: severity_cstr = "DBUG"; break;
case LogSeverity_Info: severity_cstr = "INFO"; break;
case LogSeverity_Warn: severity_cstr = "WARN"; break;
case LogSeverity_Error: severity_cstr = "ERRR"; break;
}
DateTime dt;
DateTime_getLocal(&dt);
printf("[" FMT_DateTime_text "][%s/%s]: %s\n", DT_expand(dt), context, severity_cstr, msg);
}
Result(void) run_ServerMode(cstr config_path) {
Deferral(4);
// open file
try(FILE* config_file, p, file_open(config_path, FO_ReadExisting));
Defer(file_close(config_file));
// read whole file into str
Array(u8) config_buf = Array_null;
try_void(file_readWhole(config_file, &config_buf));
Defer(Array_free(config_buf));
str config_str = Array_castTo_str(config_buf, false);
config_buf.data = NULL;
// init server
try(Server* server, p, Server_create(config_str, NULL, log_func));
Defer(Server_free(server));
// manually close file and free config_buf
file_close(config_file);
config_file = NULL;
Array_free(config_buf);
// start infinite loop on main thread
try_void(Server_run(server));
Return RESULT_VOID;
}

19
src/cli/modes/modes.h Normal file
View File

@ -0,0 +1,19 @@
#pragma once
#include "tlibc/errors.h"
#include "tlibc/filesystem.h"
typedef enum ProgramMode {
ClientMode,
ServerMode,
RsaGenStdin,
RsaGenRandom,
RandomBytes,
RandomBytesBase64,
} ProgramMode;
Result(void) run_ClientMode(cstr config_path);
Result(void) run_ServerMode(cstr config_path);
Result(void) run_RsaGenStdin(u32 key_size);
Result(void) run_RsaGenRandom(u32 key_size);
Result(void) run_RandomBytes(u32 key_size);
Result(void) run_RandomBytesBase64(u32 key_size);

1
src/cryptography/cryptography.h
View File

@ -2,6 +2,7 @@
#include "tlibc/collections/Array.h"
#include "tlibc/errors.h"
#include "bearssl_rand.h"
#include "bearssl_hash.h"
#include "tcp-chat/common_constants.h"
//////////////////////////////////////////////////////////////////////////////

1
src/cryptography/hash.c
View File

@ -1,5 +1,4 @@
#include "cryptography.h"
#include "bearssl_hash.h"
#include "assert.h"
void hash_password(Array(u8) password, u8* out_buffer, i32 iterations){