loic/libft_ssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: replace x_decode function by a generic MACRO

Browse source
This commit is contained in:
lohhiiccc 2026-05-18 10:32:49 +02:00
parent b423cde817
commit 8a1162436c
4 changed files with 29 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
include/decode.h Normal file
View file

@ -0,0 +1,23 @@
/* Generic decode macro:
* DECODE_GENERIC(block, dest, count, bytes, type, is_big_endian)
* - block: uint8_t array pointer
* - dest: destination array (type[])
* - count: number of words
* - bytes: bytes per word (e.g., 4 or 8)
* - type: integer type (e.g., uint32_t, uint64_t)
* - is_big_endian: 1 for big-endian decode, 0 for little-endian decode
*/
#define DECODE_GENERIC(block, dest, count, bytes, type, is_big_endian) \
do { \
for (size_t _i = 0; _i < (count); ++_i) { \
const size_t _off = _i * (bytes); \
(dest)[_i] = (type)0; \
if (is_big_endian) { \
for (size_t _b = 0; _b < (bytes); ++_b) \
(dest)[_i] |= (type)(block[_off + _b]) << (8 * ((bytes) - 1 - _b)); \
} else { \
for (size_t _b = 0; _b < (bytes); ++_b) \
(dest)[_i] |= (type)(block[_off + _b]) << (8 * _b); \
} \
} \
} while (0)

20
src/md5/md5_compress.c
View file

@ -1,4 +1,5 @@
#include "md5_internal.h"
#include "decode.h"
#include <stdint.h>
/* Forward declrations */
@ -14,7 +15,6 @@ static uint32_t md5_k1(uint8_t i);
static uint32_t md5_k2(uint8_t i);
static uint32_t md5_k3(uint8_t i);
static uint32_t md5_leftrotate(uint32_t x, uint32_t n);
static void md5_decode(const uint8_t block[64], uint32_t m[16]);
/* ------------------- */
static const md5_round_fn round_fns[4] = { md5_f, md5_g, md5_h, md5_i };
@ -27,7 +27,7 @@ md5_compress(struct md5_ctx *ctx, const uint8_t block[64])
uint32_t a, b, c, d;
uint32_t temp;
md5_decode(block, m);
DECODE_GENERIC(block, m, 16, 4, uint32_t, 0);
a = ctx->state[0];
b = ctx->state[1];
@ -50,22 +50,6 @@ md5_compress(struct md5_ctx *ctx, const uint8_t block[64])
ctx->state[3] += d;
}
/* Decode 64 bytes into 16 x uint32_t words (little-endian) */
static void
md5_decode(const uint8_t block[64], uint32_t m[16])
{
for (uint8_t i = 0; i < 16; ++i)
{
const uint8_t i4 = i * 4;
m[i] = (uint32_t)block[i4 + 0] << 0
| (uint32_t)block[i4 + 1] << 8
| (uint32_t)block[i4 + 2] << 16
| (uint32_t)block[i4 + 3] << 24;
}
}
/* Round functions */
static uint32_t
md5_f(uint32_t b, uint32_t c, uint32_t d)

19
src/sha256/sha256_compress.c
View file

@ -1,5 +1,6 @@
#include "sha256.h"
#include "sha256_internal.h"
#include "decode.h"
#include <stdint.h>
/* Forward declarations */
@ -10,7 +11,6 @@ static uint32_t sha256_Sigma0(uint32_t x);
static uint32_t sha256_Sigma1(uint32_t x);
static uint32_t sha256_sigma0(uint32_t x);
static uint32_t sha256_sigma1(uint32_t x);
static void sha256_decode(const uint8_t block[64], uint32_t w[16]);
static void sha256_schedule(uint32_t w[64], const uint8_t block[64]);
static void sha256_rounds(uint32_t state[8], const uint32_t w[64]);
/* ------------- */
@ -27,7 +27,7 @@ sha256_compress(struct sha256_ctx *ctx, const uint8_t block[64])
static void
sha256_schedule(uint32_t w[64], const uint8_t block[64])
{
sha256_decode(block, w);
DECODE_GENERIC(block, w, 16, 4, uint32_t, 1);
for (uint8_t i = 16; i < 64; ++i)
{
@ -72,21 +72,6 @@ sha256_rounds(uint32_t state[8], const uint32_t w[64])
state[7] += h;
}
/* Decode 64 bytes into 16 x uint32_t words (big-endian) */
static void
sha256_decode(const uint8_t block[64], uint32_t w[16])
{
for (uint8_t i = 0; i < 16; ++i)
{
const uint8_t i4 = i * 4;
w[i] = (uint32_t)block[i4 + 0] << 24
| (uint32_t)block[i4 + 1] << 16
| (uint32_t)block[i4 + 2] << 8
| (uint32_t)block[i4 + 3] << 0;
}
}
static uint32_t
sha256_rotr(uint32_t x, uint32_t n)
{

21
src/whirlpool/whirlpool_compress.c
View file

@ -1,4 +1,5 @@
#include "whirlpool_internal.h"
#include "decode.h"
#include <stddef.h>
#include <stdint.h>
#include <string.h>
@ -10,7 +11,6 @@ static void sub_bytes(uint64_t state[8]);
static void shift_columns(uint64_t state[8]);
static void mix_rows(uint64_t state[8]);
static inline void add_round_key(uint64_t state[8], const uint64_t key[8]);
static void decode_block(const uint8_t block[64], uint64_t W[8]);
static void round_function(uint64_t state[8], const uint64_t
key[8]);
/* ---------------- */
@ -21,7 +21,7 @@ void whirlpool_compress(struct whirlpool_ctx *ctx, const uint8_t block[64])
uint64_t L[8];
uint64_t K[11][8];
decode_block(block, W);
DECODE_GENERIC(block, W, 8, 8, uint64_t, 1);
memcpy(K[0], ctx->state, sizeof(ctx->state));
@ -51,23 +51,6 @@ round_function(uint64_t state[8], const uint64_t key[8])
add_round_key(state, key);
}
static void
decode_block(const uint8_t block[64], uint64_t W[8])
{
for (uint8_t i = 0; i < 8; ++i)
{
const uint8_t i8 = i * 8;
W[i] = ((uint64_t)block[i8 + 0] << 56)
| ((uint64_t)block[i8 + 1] << 48)
| ((uint64_t)block[i8 + 2] << 40)
| ((uint64_t)block[i8 + 3] << 32)
| ((uint64_t)block[i8 + 4] << 24)
| ((uint64_t)block[i8 + 5] << 16)
| ((uint64_t)block[i8 + 6] << 8)
| ((uint64_t)block[i8 + 7] << 0);
}
}
static inline uint8_t
gf_mul2(uint8_t a)
{