From c8e1be6e6042d3e37e2a660dc4a1c8c6310419b8 Mon Sep 17 00:00:00 2001 From: Andrey Rys Date: Thu, 21 Mar 2019 16:47:59 +0700 Subject: [PATCH] Rename functions and definitions so that both tfcipher and tfnoisegen code may coexist in programs. --- Makefile | 10 ++++---- README | 8 +++++- tfcore.h | 16 ++++++------ tfdef.h | 38 +++++++++++++-------------- tfe.c | 34 ++++++++++++------------ tfe.h | 18 ++++++------- tfenc.c | 8 +++--- tfprng.c | 78 ++++++++++++++++++++++++++++---------------------------- tfprng.h | 30 +++++++++++----------- tfrand.c | 8 +++--- 10 files changed, 127 insertions(+), 121 deletions(-) diff --git a/Makefile b/Makefile index d4b613c..3ef1d62 100644 --- a/Makefile +++ b/Makefile @@ -11,17 +11,17 @@ else override CFLAGS+=-O3 endif -default: $(OBJS) libtf.a tfrand -all: $(OBJS) libtf.a $(PROGS) +default: $(OBJS) libtfng.a tfrand +all: $(OBJS) libtfng.a $(PROGS) %.o: %.c $(HDRS) $(CC) $(CFLAGS) -c -o $@ $< -libtf.a: $(OBJS) +libtfng.a: $(OBJS) $(AR) cru $@ $^ -$(PROGS): %: %.o libtf.a +$(PROGS): %: %.o libtfng.a $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ clean: - rm -f libtf.a $(OBJS) $(PROGOBJS) $(SUPPOBJS) $(PROGS) + rm -f libtfng.a $(OBJS) $(PROGOBJS) $(SUPPOBJS) $(PROGS) diff --git a/README b/README index 63f1e7c..81c5011 100644 --- a/README +++ b/README @@ -25,10 +25,16 @@ USAGE ./tfrand | tfcrypt -V.5 -P - /dev/null - Use libtf.a library in your code, see headers for function references: + Use libtfng.a library in your code, see headers for function references: tfe.h: STREAM reference. tfprng.h: PRNG reference. + When building together with code which uses tfcipher library, please put + both tfcipher and tfnoisegen code in separate locations, and do not include + headers which are used privately by both implementations! Only public headers + and libtfng.a library externals are guaranteed to be namespace clean. + File names and private headers definitions are mostly same. + WARNING Do NOT use it as cipher! It's just a random block generator. You have been warned. diff --git a/tfcore.h b/tfcore.h index f2dd59a..5e52d2a 100644 --- a/tfcore.h +++ b/tfcore.h @@ -1,7 +1,7 @@ -#ifndef _THREEFISH_CIPHER_CORE_HEADER -#define _THREEFISH_CIPHER_CORE_HEADER +#ifndef _THREEFISH_NOISE_GENERATOR_CIPHER_CORE_HEADER +#define _THREEFISH_NOISE_GENERATOR_CIPHER_CORE_HEADER -#ifndef _THREEFISH_CIPHER_DEFINITIONS_HEADER +#ifndef _THREEFISH_NOISE_GENERATOR_CIPHER_DEFINITIONS_HEADER #error Threefish definitions header is required! Include tfdef.h first. #endif @@ -13,21 +13,21 @@ x += k1; \ y += x; \ y += k2; \ - x = ROL(x, sl, TF_UNIT_BITS); \ + x = ROL(x, sl, TFNG_UNIT_BITS); \ x ^= y; \ } while (0) #define BE_MIX(x, y, sl) \ do { \ x += y; \ - y = ROL(y, sl, TF_UNIT_BITS); \ + y = ROL(y, sl, TFNG_UNIT_BITS); \ y ^= x; \ } while (0) #define KD_MIX(x, y, k1, k2, sr) \ do { \ x ^= y; \ - x = ROR(x, sr, TF_UNIT_BITS); \ + x = ROR(x, sr, TFNG_UNIT_BITS); \ y -= x; \ y -= k2; \ x -= k1; \ @@ -36,11 +36,11 @@ #define BD_MIX(x, y, sr) \ do { \ y ^= x; \ - y = ROR(y, sr, TF_UNIT_BITS); \ + y = ROR(y, sr, TFNG_UNIT_BITS); \ x -= y; \ } while (0) -enum tf_rotations { +enum tfng_rotations { TFS_KS01 = 7, TFS_KS02 = 25, TFS_KS03 = 19, TFS_KS04 = 7, TFS_BS01 = 5, TFS_BS02 = 27, TFS_BS03 = 26, TFS_BS04 = 6, TFS_BS05 = 14, TFS_BS06 = 11, TFS_BS07 = 24, TFS_BS08 = 18, diff --git a/tfdef.h b/tfdef.h index 017e55c..86cf5b6 100644 --- a/tfdef.h +++ b/tfdef.h @@ -1,5 +1,5 @@ -#ifndef _THREEFISH_CIPHER_DEFINITIONS_HEADER -#define _THREEFISH_CIPHER_DEFINITIONS_HEADER +#ifndef _THREEFISH_NOISE_GENERATOR_CIPHER_DEFINITIONS_HEADER +#define _THREEFISH_NOISE_GENERATOR_CIPHER_DEFINITIONS_HEADER #ifndef _DEFAULT_SOURCE #define _DEFAULT_SOURCE @@ -14,28 +14,28 @@ #include "machdefs.h" #if defined(MACHINE_64BIT) -#define TF_UNIT_TYPE uint64_t -#define TF_NR_BLOCK_BITS 256 -#define TF_NR_KEY_BITS 512 +#define TFNG_UNIT_TYPE uint64_t +#define TFNG_NR_BLOCK_BITS 256 +#define TFNG_NR_KEY_BITS 512 #else -#define TF_UNIT_TYPE uint32_t -#define TF_NR_BLOCK_BITS 128 -#define TF_NR_KEY_BITS 256 +#define TFNG_UNIT_TYPE uint32_t +#define TFNG_NR_BLOCK_BITS 128 +#define TFNG_NR_KEY_BITS 256 #endif -#define TF_NR_BLOCK_UNITS 4 -#define TF_NR_KEY_UNITS 8 +#define TFNG_NR_BLOCK_UNITS 4 +#define TFNG_NR_KEY_UNITS 8 -#define TF_BYTE_TYPE uint8_t -#define TF_SIZE_UNIT (sizeof(TF_UNIT_TYPE)) -#define TF_BLOCK_SIZE (TF_SIZE_UNIT * TF_NR_BLOCK_UNITS) -#define TF_KEY_SIZE (TF_SIZE_UNIT * TF_NR_KEY_UNITS) +#define TFNG_BYTE_TYPE uint8_t +#define TFNG_SIZE_UNIT (sizeof(TFNG_UNIT_TYPE)) +#define TFNG_BLOCK_SIZE (TFNG_SIZE_UNIT * TFNG_NR_BLOCK_UNITS) +#define TFNG_KEY_SIZE (TFNG_SIZE_UNIT * TFNG_NR_KEY_UNITS) -#define TF_TO_BITS(x) ((x) * 8) -#define TF_FROM_BITS(x) ((x) / 8) -#define TF_MAX_BITS TF_NR_BLOCK_BITS -#define TF_UNIT_BITS (TF_SIZE_UNIT * 8) +#define TFNG_TO_BITS(x) ((x) * 8) +#define TFNG_FROM_BITS(x) ((x) / 8) +#define TFNG_MAX_BITS TFNG_NR_BLOCK_BITS +#define TFNG_UNIT_BITS (TFNG_SIZE_UNIT * 8) -void tf_encrypt_rawblk(TF_UNIT_TYPE *O, const TF_UNIT_TYPE *I, const TF_UNIT_TYPE *K); +void tfng_encrypt_rawblk(TFNG_UNIT_TYPE *O, const TFNG_UNIT_TYPE *I, const TFNG_UNIT_TYPE *K); #endif diff --git a/tfe.c b/tfe.c index 8c58979..ec4f4e2 100644 --- a/tfe.c +++ b/tfe.c @@ -2,26 +2,26 @@ #include "tfdef.h" #include "tfe.h" -void tfe_init_iv(struct tfe_stream *tfe, const void *key, const void *iv) +void tfnge_init_iv(struct tfnge_stream *tfe, const void *key, const void *iv) { - memset(tfe, 0, sizeof(struct tfe_stream)); - memcpy(tfe->key, key, TF_KEY_SIZE); - if (iv) memcpy(tfe->iv, iv, TF_BLOCK_SIZE); + memset(tfe, 0, sizeof(struct tfnge_stream)); + memcpy(tfe->key, key, TFNG_KEY_SIZE); + if (iv) memcpy(tfe->iv, iv, TFNG_BLOCK_SIZE); tfe->carry_bytes = 0; } -void tfe_init(struct tfe_stream *tfe, const void *key) +void tfnge_init(struct tfnge_stream *tfe, const void *key) { - tfe_init_iv(tfe, key, NULL); + tfnge_init_iv(tfe, key, NULL); } -void tfe_emit(void *dst, size_t szdst, struct tfe_stream *tfe) +void tfnge_emit(void *dst, size_t szdst, struct tfnge_stream *tfe) { - TF_BYTE_TYPE *udst = dst; + TFNG_BYTE_TYPE *udst = dst; size_t sz = szdst; if (!dst && szdst == 0) { - memset(tfe, 0, sizeof(struct tfe_stream)); + memset(tfe, 0, sizeof(struct tfnge_stream)); return; } @@ -39,19 +39,19 @@ void tfe_emit(void *dst, size_t szdst, struct tfe_stream *tfe) tfe->carry_bytes = 0; } - if (sz >= TF_BLOCK_SIZE) { + if (sz >= TFNG_BLOCK_SIZE) { do { - tf_encrypt_rawblk(tfe->iv, tfe->iv, tfe->key); - memcpy(udst, tfe->iv, TF_BLOCK_SIZE); - udst += TF_BLOCK_SIZE; - } while ((sz -= TF_BLOCK_SIZE) >= TF_BLOCK_SIZE); + tfng_encrypt_rawblk(tfe->iv, tfe->iv, tfe->key); + memcpy(udst, tfe->iv, TFNG_BLOCK_SIZE); + udst += TFNG_BLOCK_SIZE; + } while ((sz -= TFNG_BLOCK_SIZE) >= TFNG_BLOCK_SIZE); } if (sz) { - tf_encrypt_rawblk(tfe->iv, tfe->iv, tfe->key); + tfng_encrypt_rawblk(tfe->iv, tfe->iv, tfe->key); memcpy(udst, tfe->iv, sz); - udst = (TF_BYTE_TYPE *)tfe->iv; - tfe->carry_bytes = TF_BLOCK_SIZE-sz; + udst = (TFNG_BYTE_TYPE *)tfe->iv; + tfe->carry_bytes = TFNG_BLOCK_SIZE-sz; memcpy(tfe->carry_block, udst+sz, tfe->carry_bytes); } } diff --git a/tfe.h b/tfe.h index f5793b1..8ee9d29 100644 --- a/tfe.h +++ b/tfe.h @@ -1,17 +1,17 @@ -#ifndef _TF_STREAM_CIPHER_DEFS -#define _TF_STREAM_CIPHER_DEFS +#ifndef _TFNG_STREAM_CIPHER_DEFS +#define _TFNG_STREAM_CIPHER_DEFS #include "tfdef.h" -struct tfe_stream { - TF_UNIT_TYPE key[TF_NR_KEY_UNITS]; - TF_UNIT_TYPE iv[TF_NR_BLOCK_UNITS]; - TF_BYTE_TYPE carry_block[TF_BLOCK_SIZE]; +struct tfnge_stream { + TFNG_UNIT_TYPE key[TFNG_NR_KEY_UNITS]; + TFNG_UNIT_TYPE iv[TFNG_NR_BLOCK_UNITS]; + TFNG_BYTE_TYPE carry_block[TFNG_BLOCK_SIZE]; size_t carry_bytes; }; -void tfe_init(struct tfe_stream *tfe, const void *key); -void tfe_init_iv(struct tfe_stream *tfe, const void *key, const void *iv); -void tfe_emit(void *dst, size_t szdst, struct tfe_stream *tfe); +void tfnge_init(struct tfnge_stream *tfe, const void *key); +void tfnge_init_iv(struct tfnge_stream *tfe, const void *key, const void *iv); +void tfnge_emit(void *dst, size_t szdst, struct tfnge_stream *tfe); #endif diff --git a/tfenc.c b/tfenc.c index d0727dc..4ee585e 100644 --- a/tfenc.c +++ b/tfenc.c @@ -21,11 +21,11 @@ BE_MIX(X, T, TFS_BS11); BE_MIX(Z, Y, TFS_BS12); \ } while (0) -void tf_encrypt_rawblk(TF_UNIT_TYPE *O, const TF_UNIT_TYPE *I, const TF_UNIT_TYPE *K) +void tfng_encrypt_rawblk(TFNG_UNIT_TYPE *O, const TFNG_UNIT_TYPE *I, const TFNG_UNIT_TYPE *K) { - TF_UNIT_TYPE X, Y, Z, T; - TF_UNIT_TYPE K0, K1, K2, K3; - TF_UNIT_TYPE K4, T0, T1, T2; + TFNG_UNIT_TYPE X, Y, Z, T; + TFNG_UNIT_TYPE K0, K1, K2, K3; + TFNG_UNIT_TYPE K4, T0, T1, T2; X = I[0]; Y = I[1]; Z = I[2]; T = I[3]; diff --git a/tfprng.c b/tfprng.c index d4370f3..5022857 100644 --- a/tfprng.c +++ b/tfprng.c @@ -2,93 +2,93 @@ #include "tfe.h" #include "tfprng.h" -struct tf_prng_data { - struct tfe_stream tfe; +struct tfng_prng_data { + struct tfnge_stream tfe; short init; }; -struct tf_prng_data tf_prng_sdata; +struct tfng_prng_data tfng_prng_sdata; -size_t tf_prng_datasize(void) +size_t tfng_prng_datasize(void) { - return sizeof(struct tf_prng_data); + return sizeof(struct tfng_prng_data); } -void tf_prng_seedkey_r(void *sdata, const void *skey) +void tfng_prng_seedkey_r(void *sdata, const void *skey) { - TF_UNIT_TYPE k[TF_NR_KEY_UNITS]; - struct tf_prng_data *rprng = sdata; + TFNG_UNIT_TYPE k[TFNG_NR_KEY_UNITS]; + struct tfng_prng_data *rprng = sdata; - memset(rprng, 0, tf_prng_datasize()); + memset(rprng, 0, tfng_prng_datasize()); if (!skey) return; - memcpy(k, skey, TF_KEY_SIZE); - tfe_init(&rprng->tfe, k); + memcpy(k, skey, TFNG_KEY_SIZE); + tfnge_init(&rprng->tfe, k); rprng->init = 1; - memset(k, 0, TF_KEY_SIZE); + memset(k, 0, TFNG_KEY_SIZE); } -void tf_prng_seedkey(const void *skey) +void tfng_prng_seedkey(const void *skey) { - tf_prng_seedkey_r(&tf_prng_sdata, skey); + tfng_prng_seedkey_r(&tfng_prng_sdata, skey); } -void tf_prng_genrandom_r(void *sdata, void *result, size_t need) +void tfng_prng_genrandom_r(void *sdata, void *result, size_t need) { - struct tf_prng_data *rprng = sdata; + struct tfng_prng_data *rprng = sdata; memset(result, 0, need); - tfe_emit(result, need, &rprng->tfe); + tfnge_emit(result, need, &rprng->tfe); } -void tf_prng_genrandom(void *result, size_t need) +void tfng_prng_genrandom(void *result, size_t need) { - tf_prng_genrandom_r(&tf_prng_sdata, result, need); + tfng_prng_genrandom_r(&tfng_prng_sdata, result, need); } -void tf_prng_seed_r(void *sdata, TF_UNIT_TYPE seed) +void tfng_prng_seed_r(void *sdata, TFNG_UNIT_TYPE seed) { - TF_UNIT_TYPE k[TF_NR_KEY_UNITS]; - struct tf_prng_data *rprng = sdata; + TFNG_UNIT_TYPE k[TFNG_NR_KEY_UNITS]; + struct tfng_prng_data *rprng = sdata; size_t x; - memset(rprng, 0, tf_prng_datasize()); - for (x = 0; x < TF_NR_KEY_UNITS; x++) k[x] = seed; - tfe_init(&rprng->tfe, k); + memset(rprng, 0, tfng_prng_datasize()); + for (x = 0; x < TFNG_NR_KEY_UNITS; x++) k[x] = seed; + tfnge_init(&rprng->tfe, k); rprng->init = 1; - memset(k, 0, TF_KEY_SIZE); + memset(k, 0, TFNG_KEY_SIZE); } -void tf_prng_seed(TF_UNIT_TYPE seed) +void tfng_prng_seed(TFNG_UNIT_TYPE seed) { - tf_prng_seed_r(&tf_prng_sdata, seed); + tfng_prng_seed_r(&tfng_prng_sdata, seed); } -TF_UNIT_TYPE tf_prng_random_r(void *sdata) +TFNG_UNIT_TYPE tfng_prng_random_r(void *sdata) { - struct tf_prng_data *rprng = sdata; - TF_UNIT_TYPE r; + struct tfng_prng_data *rprng = sdata; + TFNG_UNIT_TYPE r; if (!rprng->init) return 0; - tfe_emit(&r, sizeof(r), &rprng->tfe); + tfnge_emit(&r, sizeof(r), &rprng->tfe); return r; } -TF_UNIT_TYPE tf_prng_random(void) +TFNG_UNIT_TYPE tfng_prng_random(void) { - return tf_prng_random_r(&tf_prng_sdata); + return tfng_prng_random_r(&tfng_prng_sdata); } -TF_UNIT_TYPE tf_prng_range_r(void *sdata, TF_UNIT_TYPE s, TF_UNIT_TYPE d) +TFNG_UNIT_TYPE tfng_prng_range_r(void *sdata, TFNG_UNIT_TYPE s, TFNG_UNIT_TYPE d) { - TF_UNIT_TYPE c = tf_prng_random_r(sdata); + TFNG_UNIT_TYPE c = tfng_prng_random_r(sdata); if (d <= s) return s; - return s + c / ((TF_UNIT_TYPE)~0 / (d - s + 1) + 1); + return s + c / ((TFNG_UNIT_TYPE)~0 / (d - s + 1) + 1); } -TF_UNIT_TYPE tf_prng_range(TF_UNIT_TYPE s, TF_UNIT_TYPE d) +TFNG_UNIT_TYPE tfng_prng_range(TFNG_UNIT_TYPE s, TFNG_UNIT_TYPE d) { - return tf_prng_range_r(&tf_prng_sdata, s, d); + return tfng_prng_range_r(&tfng_prng_sdata, s, d); } diff --git a/tfprng.h b/tfprng.h index 5fbab0a..f7d3b3f 100644 --- a/tfprng.h +++ b/tfprng.h @@ -1,22 +1,22 @@ -#ifndef _TF_PRNG_DEFINITIONS_HEADER -#define _TF_PRNG_DEFINITIONS_HEADER +#ifndef _TFNG_PRNG_DEFINITIONS_HEADER +#define _TFNG_PRNG_DEFINITIONS_HEADER #include #include "tfdef.h" -#define TF_PRNG_KEY_SIZE TF_KEY_SIZE -#define TF_PRNG_SIZE_UNIT TF_SIZE_UNIT +#define TFNG_PRNG_KEY_SIZE TFNG_KEY_SIZE +#define TFNG_PRNG_SIZE_UNIT TFNG_SIZE_UNIT -size_t tf_prng_datasize(void); -void tf_prng_seedkey_r(void *sdata, const void *skey); -void tf_prng_seedkey(const void *skey); -void tf_prng_genrandom_r(void *sdata, void *result, size_t need); -void tf_prng_genrandom(void *result, size_t need); -void tf_prng_seed_r(void *sdata, TF_UNIT_TYPE seed); -void tf_prng_seed(TF_UNIT_TYPE seed); -TF_UNIT_TYPE tf_prng_random_r(void *sdata); -TF_UNIT_TYPE tf_prng_random(void); -TF_UNIT_TYPE tf_prng_range_r(void *sdata, TF_UNIT_TYPE s, TF_UNIT_TYPE d); -TF_UNIT_TYPE tf_prng_range(TF_UNIT_TYPE s, TF_UNIT_TYPE d); +size_t tfng_prng_datasize(void); +void tfng_prng_seedkey_r(void *sdata, const void *skey); +void tfng_prng_seedkey(const void *skey); +void tfng_prng_genrandom_r(void *sdata, void *result, size_t need); +void tfng_prng_genrandom(void *result, size_t need); +void tfng_prng_seed_r(void *sdata, TFNG_UNIT_TYPE seed); +void tfng_prng_seed(TFNG_UNIT_TYPE seed); +TFNG_UNIT_TYPE tfng_prng_random_r(void *sdata); +TFNG_UNIT_TYPE tfng_prng_random(void); +TFNG_UNIT_TYPE tfng_prng_range_r(void *sdata, TFNG_UNIT_TYPE s, TFNG_UNIT_TYPE d); +TFNG_UNIT_TYPE tfng_prng_range(TFNG_UNIT_TYPE s, TFNG_UNIT_TYPE d); #endif diff --git a/tfrand.c b/tfrand.c index cbbe82a..5372e20 100644 --- a/tfrand.c +++ b/tfrand.c @@ -8,7 +8,7 @@ #define DATASIZE 65536 static char data[DATASIZE]; -static char key[TF_KEY_SIZE]; +static char key[TFNG_KEY_SIZE]; int main(int argc, char **argv) { @@ -20,12 +20,12 @@ int main(int argc, char **argv) close(fd); } - tf_prng_seedkey(key); + tfng_prng_seedkey(key); while (1) { - tf_prng_genrandom(data, DATASIZE); + tfng_prng_genrandom(data, DATASIZE); if (write(1, data, DATASIZE) == -1) return 1; } - tf_prng_seedkey(NULL); + tfng_prng_seedkey(NULL); return 0; }