Timerix/tcp-chat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
1b00f503c8
tcp-chat/src/cli/main.c

299 lines
11 KiB
C
Raw Blame History

#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"
#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);
try_fatal_void(tlibc_init());
Defer(tlibc_deinit());
try_fatal_void(network_init());
Defer(network_deinit());
if(br_prng_seeder_system(NULL) == NULL){
printfe("Can't get system random seeder. Bearssl is compiled incorrectly.");
return 1;
}
ProgramMode mode = ClientMode;
cstr config_path = NULL;
u32 size_arg = 0;
for(int argi = 1; argi < argc; argi++){
str arg_str = str_from_cstr(argv[argi]);
if(arg_is("-h") || arg_is("--help")){
printf(
"USAGE:\n"
"no arguments Interactive client mode.\n"
"-h, --help Show this message.\n"
"-l, --listen Start server.\n"
"--config [path] Load config from specified path.\n"
" Default path for config is '" _DEFAULT_CONFIG_PATH_CLIENT "' or '" _DEFAULT_CONFIG_PATH_SERVER "'\n"
"--rsa-gen-stdin [size] Generate RSA private and public keys based on stdin data (64Kb max).\n"
" size: 2048 / 3072 (default) / 4096\n"
" Usage: `cat somefile | tcp-chat --gen-rsa-stdin`\n"
"--rsa-gen-random [size] Generate random RSA private and public keys.\n"
" size: 2048 / 3072 (default) / 4096\n"
"--random-bytes [size] Generate random bytes.\n"
" size: any number (default=32)\n"
"--random-bytes-base64 [size] Generate random bytes and print them in base64 encoding.\n"
" size: any number (default=32)\n"
);
Return 0;
}
if(arg_is("-l") || arg_is("--listen")){
if(mode != ClientMode){
printf("program mode is set already\n");
Return 1;
}
mode = ServerMode;
}
else if(arg_is("--config")){
if(++argi >= argc){
printfe("ERROR: no config path specified\n");
Return 1;
}
config_path = argv[argi];
}
else if(arg_is("--rsa-gen-stdin")){
if(mode != ClientMode){
printf("program mode is set already\n");
Return 1;
}
mode = RsaGenStdin;
if(++argi >= argc){
size_arg = RSA_DEFAULT_KEY_SIZE;
}
else if(sscanf(argv[argi], "%u", &size_arg) != 1){
printfe("ERROR: no key size specified\n");
}
}
else if(arg_is("--rsa-gen-random")){
if(mode != ClientMode){
printf("program mode is set already\n");
Return 1;
}
mode = RsaGenRandom;
if(++argi >= argc){
size_arg = RSA_DEFAULT_KEY_SIZE;
}
else if(sscanf(argv[argi], "%u", &size_arg) != 1){
printfe("ERROR: no key size specified\n");
}
}
else if(arg_is("--random-bytes")){
if(mode != ClientMode){
printf("program mode is set already\n");
Return 1;
}
mode = RandomBytes;
if(++argi >= argc){
size_arg = 32;
}
else if(sscanf(argv[argi], "%u", &size_arg) != 1){
printfe("ERROR: no size specified\n");
}
}
else if(arg_is("--random-bytes-base64")){
if(mode != ClientMode){
printf("program mode is set already\n");
Return 1;
}
mode = RandomBytesBase64;
if(++argi >= argc){
size_arg = 32;
}
else if(sscanf(argv[argi], "%u", &size_arg) != 1){
printfe("ERROR: no size specified\n");
}
}
else {
printfe("ERROR: unknown argument '%s'\n"
"Use '-h' to see list of avaliable arguments\n",
argv[argi]);
Return 1;
}
}
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;
}
Return 0;
}
Reference in New Issue View Git Blame Copy Permalink