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

refactored tlibc collections

Browse Source
This commit is contained in:
Timerix
2025-11-25 16:31:58 +05:00
parent 7a3808ba59
commit 8bc98a321d
32 changed files with 294 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
src/cryptography/AES.c
View File

@@ -4,19 +4,19 @@
// 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_u8_sliceFrom(*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_u8_sliceFrom(*src, size);
}
static void __calcKeyCheckSum(Array(u8) key, void* dst){
br_sha256_context sha_ctx;
br_sha256_init(&sha_ctx);
br_sha256_update(&sha_ctx, key.data, key.size);
br_sha256_update(&sha_ctx, key.data, key.len);
br_sha256_out(&sha_ctx, dst);
}
@@ -37,8 +37,8 @@ void AESBlockEncryptor_construct(AESBlockEncryptor* ptr,
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);
assert(key.len == 16 || key.len == 24 || key.len == 32);
ptr->enc_class->init((void*)ptr->enc_keys, key.data, key.len);
__calcKeyCheckSum(key, ptr->key_checksum);
}
@@ -46,8 +46,8 @@ 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);
u32 encrypted_size = AESBlockEncryptor_calcDstSize(src.len);
try_assert(dst.len >= encrypted_size);
// generate random initial vector
br_hmac_drbg_generate(&ptr->rng_ctx, ptr->iv, __AES_BLOCK_IV_SIZE);
@@ -57,7 +57,7 @@ Result(u32) AESBlockEncryptor_encrypt(AESBlockEncryptor* ptr,
EncryptedBlockHeader header;
memset(&header, 0, sizeof(header));
memcpy(header.key_checksum, ptr->key_checksum, __AES_BLOCK_KEY_CHECKSUM_SIZE);
header.padding_size = (16 - src.size % 16) % 16;
header.padding_size = (16 - src.len % 16) % 16;
// write header to buffer
memcpy(ptr->buf, &header, sizeof(header));
// encrypt header
@@ -66,7 +66,7 @@ Result(u32) AESBlockEncryptor_encrypt(AESBlockEncryptor* ptr,
__Array_writeNext(&dst, ptr->buf, sizeof(header));
// encrypt full AESBlockEncryptor buffers
while(src.size > __AES_BUFFER_SIZE){
while(src.len > __AES_BUFFER_SIZE){
__Array_readNext(ptr->buf, &src, __AES_BUFFER_SIZE);
ptr->enc_class->run((void*)ptr->enc_keys,
ptr->iv,
@@ -75,10 +75,10 @@ Result(u32) AESBlockEncryptor_encrypt(AESBlockEncryptor* ptr,
}
// encrypt buffer with remaining data
if(src.size > 0){
memcpy(ptr->buf, src.data, src.size);
memset(ptr->buf + src.size, 0, header.padding_size);
u32 src_size_padded = src.size + header.padding_size;
if(src.len > 0){
memcpy(ptr->buf, src.data, src.len);
memset(ptr->buf + src.len, 0, header.padding_size);
u32 src_size_padded = src.len + header.padding_size;
ptr->enc_class->run((void*)ptr->enc_keys,
ptr->iv,
ptr->buf, src_size_padded);
@@ -102,8 +102,8 @@ void AESBlockDecryptor_construct(AESBlockDecryptor* ptr,
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);
assert(key.len == 16 || key.len == 24 || key.len == 32);
ptr->dec_class->init((void*)ptr->dec_keys, key.data, key.len);
__calcKeyCheckSum(key, ptr->key_checksum);
}
@@ -112,9 +112,9 @@ Result(u32) AESBlockDecryptor_decrypt(AESBlockDecryptor* ptr,
{
Deferral(4);
u32 overhead_size = AESBlockEncryptor_calcDstSize(0);
try_assert(src.size >= overhead_size);
try_assert(src.size % 16 == 0 && "src must be array of 16-byte blocks");
try_assert(dst.size >= src.size - overhead_size);
try_assert(src.len >= overhead_size);
try_assert(src.len % 16 == 0 && "src must be array of 16-byte blocks");
try_assert(dst.len >= src.len - overhead_size);
// read IV from the beginning of src
__Array_readNext(ptr->iv, &src, __AES_BLOCK_IV_SIZE);
@@ -131,12 +131,12 @@ Result(u32) AESBlockDecryptor_decrypt(AESBlockDecryptor* ptr,
}
// size of decrypted data without padding
try_assert(src.size >= header.padding_size && "invalid padding size");
u32 decrypted_size = src.size - header.padding_size;
src.size = decrypted_size;
try_assert(src.len >= header.padding_size && "invalid padding size");
u32 decrypted_size = src.len - header.padding_size;
src.len = decrypted_size;
// decrypt full buffers
while(src.size > __AES_BUFFER_SIZE){
while(src.len > __AES_BUFFER_SIZE){
__Array_readNext(ptr->buf, &src, __AES_BUFFER_SIZE);
ptr->dec_class->run((void*)ptr->dec_keys,
ptr->iv,
@@ -145,14 +145,14 @@ Result(u32) AESBlockDecryptor_decrypt(AESBlockDecryptor* ptr,
}
// decrypt buffer with remaining data
if(src.size > 0){
memcpy(ptr->buf, src.data, src.size);
memset(ptr->buf + src.size, 0, header.padding_size);
u32 src_size_padded = src.size + header.padding_size;
if(src.len > 0){
memcpy(ptr->buf, src.data, src.len);
memset(ptr->buf + src.len, 0, header.padding_size);
u32 src_size_padded = src.len + header.padding_size;
ptr->dec_class->run((void*)ptr->dec_keys,
ptr->iv,
ptr->buf, src_size_padded);
memcpy(dst.data, ptr->buf, src.size);
memcpy(dst.data, ptr->buf, src.len);
}
Return RESULT_VALUE(u, decrypted_size);
@@ -178,8 +178,8 @@ void AESStreamEncryptor_construct(AESStreamEncryptor* ptr,
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);
assert(key.len == 16 || key.len == 24 || key.len == 32);
ptr->ctr_class->init((void*)ptr->ctr_keys, key.data, key.len);
__calcKeyCheckSum(key, ptr->key_checksum);
}
@@ -188,7 +188,7 @@ Result(u32) AESStreamEncryptor_encrypt(AESStreamEncryptor* ptr,
{
Deferral(4);
u32 encrypted_size = src.size;
u32 encrypted_size = src.len;
// if it is the beginning of the stream,
if(ptr->block_counter == 0){
// write IV generated during initialization
@@ -204,10 +204,10 @@ Result(u32) AESStreamEncryptor_encrypt(AESStreamEncryptor* ptr,
// write checksum to dst
__Array_writeNext(&dst, key_checksum, __AES_BLOCK_KEY_CHECKSUM_SIZE);
}
try_assert(dst.size >= encrypted_size);
try_assert(dst.len >= encrypted_size);
// encrypt full buffers
while(src.size > __AES_BUFFER_SIZE){
while(src.len > __AES_BUFFER_SIZE){
__Array_readNext(ptr->buf, &src, __AES_BUFFER_SIZE);
ptr->block_counter = ptr->ctr_class->run((void*)ptr->ctr_keys,
ptr->iv, ptr->block_counter,
@@ -216,12 +216,12 @@ Result(u32) AESStreamEncryptor_encrypt(AESStreamEncryptor* ptr,
}
// encrypt remaining data
if(src.size > 0){
memcpy(ptr->buf, src.data, src.size);
if(src.len > 0){
memcpy(ptr->buf, src.data, src.len);
ptr->block_counter = ptr->ctr_class->run((void*)ptr->ctr_keys,
ptr->iv, ptr->block_counter,
ptr->buf, src.size);
memcpy(dst.data, ptr->buf, src.size);
ptr->buf, src.len);
memcpy(dst.data, ptr->buf, src.len);
}
Return RESULT_VALUE(u, encrypted_size);
@@ -242,8 +242,8 @@ void AESStreamDecryptor_construct(AESStreamDecryptor* ptr,
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);
assert(key.len == 16 || key.len == 24 || key.len == 32);
ptr->ctr_class->init((void*)ptr->ctr_keys, key.data, key.len);
__calcKeyCheckSum(key, ptr->key_checksum);
}
@@ -270,11 +270,11 @@ Result(u32) AESStreamDecryptor_decrypt(AESStreamDecryptor* ptr,
}
}
// size without IV
u32 decrypted_size = src.size;
try_assert(dst.size >= decrypted_size);
u32 decrypted_size = src.len;
try_assert(dst.len >= decrypted_size);
// decrypt full buffers
while(src.size > __AES_BUFFER_SIZE){
while(src.len > __AES_BUFFER_SIZE){
__Array_readNext(ptr->buf, &src, __AES_BUFFER_SIZE);
ptr->block_counter = ptr->ctr_class->run((void*)ptr->ctr_keys,
ptr->iv, ptr->block_counter,
@@ -283,12 +283,12 @@ Result(u32) AESStreamDecryptor_decrypt(AESStreamDecryptor* ptr,
}
// decrypt remaining data
if(src.size > 0){
memcpy(ptr->buf, src.data, src.size);
if(src.len > 0){
memcpy(ptr->buf, src.data, src.len);
ptr->block_counter = ptr->ctr_class->run((void*)ptr->ctr_keys,
ptr->iv, ptr->block_counter,
ptr->buf, src.size);
memcpy(dst.data, ptr->buf, src.size);
ptr->buf, src.len);
memcpy(dst.data, ptr->buf, src.len);
}
Return RESULT_VALUE(u, decrypted_size);