localhorst
/
tfnoisegen
mirror of https://strlcat.eu/rys/tfnoisegen.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Rename functions and definitions so that both tfcipher and tfnoisegen code may coexist in programs.

This commit is contained in:
Andrey Rys 2019-03-21 16:47:59 +07:00
parent 2aa15abd13
commit c8e1be6e60
No known key found for this signature in database
GPG Key ID: ED732729967CDBC5
10 changed files with 127 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Makefile
View File

@ -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)

8
README
View File

@ -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.

16
tfcore.h
View File

@ -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,

38
tfdef.h
View File

@ -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

34
tfe.c
View File

@ -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);
}
}

18
tfe.h
View File

@ -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

8
tfenc.c
View File

@ -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];

78
tfprng.c
View File

@ -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);
}

30
tfprng.h
View File

@ -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 <stdlib.h>
#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

8
tfrand.c
View File

@ -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;
}