From c5a9061055b775d8b3928debb71216f5fdc7fced Mon Sep 17 00:00:00 2001 From: "H.Merijn Brand - Tux" Date: Mon, 28 May 2018 09:11:58 +0200 Subject: [PATCH] Anonymous unions are GNU and C11 Unrecognized on HP C-ANSI-C With this change: HP-UX 11.31/64 U ia64 hp Integrity rx2800 i2/64 Itanium(R) 9320/1361(4) ia64 cc: HP C/aC++ B3910B A.06.28.02 [Mar 09 2016] All tests successful. Files=134, Tests=29513, 120 wallclock secs ( 5.77 usr 1.11 sys + 111.76 cusr 6.55 csys = 125.19 CPU) Result: PASS --- src/ltc/headers/tomcrypt_prng.h | 2 +- src/ltc/prngs/chacha20.c | 24 ++++---- src/ltc/prngs/fortuna.c | 78 +++++++++++++------------- src/ltc/prngs/rc4.c | 24 ++++---- src/ltc/prngs/sober128.c | 24 ++++---- src/ltc/prngs/yarrow.c | 98 ++++++++++++++++----------------- 6 files changed, 125 insertions(+), 125 deletions(-) diff --git a/src/ltc/headers/tomcrypt_prng.h b/src/ltc/headers/tomcrypt_prng.h index 5d66aaaca..731cfd349 100644 --- a/src/ltc/headers/tomcrypt_prng.h +++ b/src/ltc/headers/tomcrypt_prng.h @@ -73,7 +73,7 @@ typedef struct { #ifdef LTC_SOBER128 struct sober128_prng sober128; #endif - }; + } u; short ready; /* ready flag 0-1 */ LTC_MUTEX_TYPE(lock) /* lock */ } prng_state; diff --git a/src/ltc/prngs/chacha20.c b/src/ltc/prngs/chacha20.c index 59b232276..f95ea1544 100644 --- a/src/ltc/prngs/chacha20.c +++ b/src/ltc/prngs/chacha20.c @@ -38,8 +38,8 @@ int chacha20_prng_start(prng_state *prng) { LTC_ARGCHK(prng != NULL); prng->ready = 0; - XMEMSET(&prng->chacha.ent, 0, sizeof(prng->chacha.ent)); - prng->chacha.idx = 0; + XMEMSET(&prng->u.chacha.ent, 0, sizeof(prng->u.chacha.ent)); + prng->u.chacha.idx = 0; LTC_MUTEX_INIT(&prng->lock) return CRYPT_OK; } @@ -64,18 +64,18 @@ int chacha20_prng_add_entropy(const unsigned char *in, unsigned long inlen, prng LTC_MUTEX_LOCK(&prng->lock); if (prng->ready) { /* chacha20_prng_ready() was already called, do "rekey" operation */ - if ((err = chacha_keystream(&prng->chacha.s, buf, sizeof(buf))) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = chacha_keystream(&prng->u.chacha.s, buf, sizeof(buf))) != CRYPT_OK) goto LBL_UNLOCK; for(i = 0; i < inlen; i++) buf[i % sizeof(buf)] ^= in[i]; /* key 32 bytes, 20 rounds */ - if ((err = chacha_setup(&prng->chacha.s, buf, 32, 20)) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = chacha_setup(&prng->u.chacha.s, buf, 32, 20)) != CRYPT_OK) goto LBL_UNLOCK; /* iv 8 bytes */ - if ((err = chacha_ivctr64(&prng->chacha.s, buf + 32, 8, 0)) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = chacha_ivctr64(&prng->u.chacha.s, buf + 32, 8, 0)) != CRYPT_OK) goto LBL_UNLOCK; /* clear KEY + IV */ zeromem(buf, sizeof(buf)); } else { /* chacha20_prng_ready() was not called yet, add entropy to ent buffer */ - while (inlen--) prng->chacha.ent[prng->chacha.idx++ % sizeof(prng->chacha.ent)] ^= *in++; + while (inlen--) prng->u.chacha.ent[prng->u.chacha.idx++ % sizeof(prng->u.chacha.ent)] ^= *in++; } err = CRYPT_OK; LBL_UNLOCK: @@ -97,11 +97,11 @@ int chacha20_prng_ready(prng_state *prng) LTC_MUTEX_LOCK(&prng->lock); if (prng->ready) { err = CRYPT_OK; goto LBL_UNLOCK; } /* key 32 bytes, 20 rounds */ - if ((err = chacha_setup(&prng->chacha.s, prng->chacha.ent, 32, 20)) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = chacha_setup(&prng->u.chacha.s, prng->u.chacha.ent, 32, 20)) != CRYPT_OK) goto LBL_UNLOCK; /* iv 8 bytes */ - if ((err = chacha_ivctr64(&prng->chacha.s, prng->chacha.ent + 32, 8, 0)) != CRYPT_OK) goto LBL_UNLOCK; - XMEMSET(&prng->chacha.ent, 0, sizeof(prng->chacha.ent)); - prng->chacha.idx = 0; + if ((err = chacha_ivctr64(&prng->u.chacha.s, prng->u.chacha.ent + 32, 8, 0)) != CRYPT_OK) goto LBL_UNLOCK; + XMEMSET(&prng->u.chacha.ent, 0, sizeof(prng->u.chacha.ent)); + prng->u.chacha.idx = 0; prng->ready = 1; LBL_UNLOCK: LTC_MUTEX_UNLOCK(&prng->lock); @@ -120,7 +120,7 @@ unsigned long chacha20_prng_read(unsigned char *out, unsigned long outlen, prng_ if (outlen == 0 || prng == NULL || out == NULL) return 0; LTC_MUTEX_LOCK(&prng->lock); if (!prng->ready) { outlen = 0; goto LBL_UNLOCK; } - if (chacha_keystream(&prng->chacha.s, out, outlen) != CRYPT_OK) outlen = 0; + if (chacha_keystream(&prng->u.chacha.s, out, outlen) != CRYPT_OK) outlen = 0; LBL_UNLOCK: LTC_MUTEX_UNLOCK(&prng->lock); return outlen; @@ -137,7 +137,7 @@ int chacha20_prng_done(prng_state *prng) LTC_ARGCHK(prng != NULL); LTC_MUTEX_LOCK(&prng->lock); prng->ready = 0; - err = chacha_done(&prng->chacha.s); + err = chacha_done(&prng->u.chacha.s); LTC_MUTEX_UNLOCK(&prng->lock); LTC_MUTEX_DESTROY(&prng->lock); return err; diff --git a/src/ltc/prngs/fortuna.c b/src/ltc/prngs/fortuna.c index 400c73235..8745c1178 100644 --- a/src/ltc/prngs/fortuna.c +++ b/src/ltc/prngs/fortuna.c @@ -60,7 +60,7 @@ static void _fortuna_update_iv(prng_state *prng) int x; unsigned char *IV; /* update IV */ - IV = prng->fortuna.IV; + IV = prng->u.fortuna.IV; for (x = 0; x < 16; x++) { IV[x] = (IV[x] + 1) & 255; if (IV[x] != 0) break; @@ -104,26 +104,26 @@ static int _fortuna_reseed(prng_state *prng) #ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED unsigned long now = _fortuna_current_time(); - if (now == prng->fortuna.wd) + if (now == prng->u.fortuna.wd) return CRYPT_OK; #else - if (++prng->fortuna.wd < LTC_FORTUNA_WD) + if (++prng->u.fortuna.wd < LTC_FORTUNA_WD) return CRYPT_OK; #endif /* new K == LTC_SHA256(K || s) where s == LTC_SHA256(P0) || LTC_SHA256(P1) ... */ sha256_init(&md); - if ((err = sha256_process(&md, prng->fortuna.K, 32)) != CRYPT_OK) { + if ((err = sha256_process(&md, prng->u.fortuna.K, 32)) != CRYPT_OK) { sha256_done(&md, tmp); return err; } - reset_cnt = prng->fortuna.reset_cnt + 1; + reset_cnt = prng->u.fortuna.reset_cnt + 1; for (x = 0; x < LTC_FORTUNA_POOLS; x++) { if (x == 0 || ((reset_cnt >> (x-1)) & 1) == 0) { /* terminate this hash */ - if ((err = sha256_done(&prng->fortuna.pool[x], tmp)) != CRYPT_OK) { + if ((err = sha256_done(&prng->u.fortuna.pool[x], tmp)) != CRYPT_OK) { sha256_done(&md, tmp); return err; } @@ -133,7 +133,7 @@ static int _fortuna_reseed(prng_state *prng) return err; } /* reset this pool */ - if ((err = sha256_init(&prng->fortuna.pool[x])) != CRYPT_OK) { + if ((err = sha256_init(&prng->u.fortuna.pool[x])) != CRYPT_OK) { sha256_done(&md, tmp); return err; } @@ -143,22 +143,22 @@ static int _fortuna_reseed(prng_state *prng) } /* finish key */ - if ((err = sha256_done(&md, prng->fortuna.K)) != CRYPT_OK) { + if ((err = sha256_done(&md, prng->u.fortuna.K)) != CRYPT_OK) { return err; } - if ((err = rijndael_setup(prng->fortuna.K, 32, 0, &prng->fortuna.skey)) != CRYPT_OK) { + if ((err = rijndael_setup(prng->u.fortuna.K, 32, 0, &prng->u.fortuna.skey)) != CRYPT_OK) { return err; } _fortuna_update_iv(prng); /* reset/update internals */ - prng->fortuna.pool0_len = 0; + prng->u.fortuna.pool0_len = 0; #ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED - prng->fortuna.wd = now; + prng->u.fortuna.wd = now; #else - prng->fortuna.wd = 0; + prng->u.fortuna.wd = 0; #endif - prng->fortuna.reset_cnt = reset_cnt; + prng->u.fortuna.reset_cnt = reset_cnt; #ifdef LTC_CLEAN_STACK @@ -186,7 +186,7 @@ int fortuna_update_seed(const unsigned char *in, unsigned long inlen, prng_state LTC_MUTEX_LOCK(&prng->lock); /* new K = LTC_SHA256(K || in) */ sha256_init(&md); - if ((err = sha256_process(&md, prng->fortuna.K, 32)) != CRYPT_OK) { + if ((err = sha256_process(&md, prng->u.fortuna.K, 32)) != CRYPT_OK) { sha256_done(&md, tmp); goto LBL_UNLOCK; } @@ -195,7 +195,7 @@ int fortuna_update_seed(const unsigned char *in, unsigned long inlen, prng_state goto LBL_UNLOCK; } /* finish key */ - if ((err = sha256_done(&md, prng->fortuna.K)) != CRYPT_OK) { + if ((err = sha256_done(&md, prng->u.fortuna.K)) != CRYPT_OK) { goto LBL_UNLOCK; } _fortuna_update_iv(prng); @@ -224,25 +224,25 @@ int fortuna_start(prng_state *prng) /* initialize the pools */ for (x = 0; x < LTC_FORTUNA_POOLS; x++) { - if ((err = sha256_init(&prng->fortuna.pool[x])) != CRYPT_OK) { + if ((err = sha256_init(&prng->u.fortuna.pool[x])) != CRYPT_OK) { for (y = 0; y < x; y++) { - sha256_done(&prng->fortuna.pool[y], tmp); + sha256_done(&prng->u.fortuna.pool[y], tmp); } return err; } } - prng->fortuna.pool_idx = prng->fortuna.pool0_len = prng->fortuna.wd = 0; - prng->fortuna.reset_cnt = 0; + prng->u.fortuna.pool_idx = prng->u.fortuna.pool0_len = prng->u.fortuna.wd = 0; + prng->u.fortuna.reset_cnt = 0; /* reset bufs */ - zeromem(prng->fortuna.K, 32); - if ((err = rijndael_setup(prng->fortuna.K, 32, 0, &prng->fortuna.skey)) != CRYPT_OK) { + zeromem(prng->u.fortuna.K, 32); + if ((err = rijndael_setup(prng->u.fortuna.K, 32, 0, &prng->u.fortuna.skey)) != CRYPT_OK) { for (x = 0; x < LTC_FORTUNA_POOLS; x++) { - sha256_done(&prng->fortuna.pool[x], tmp); + sha256_done(&prng->u.fortuna.pool[x], tmp); } return err; } - zeromem(prng->fortuna.IV, 16); + zeromem(prng->u.fortuna.IV, 16); LTC_MUTEX_INIT(&prng->lock) @@ -263,14 +263,14 @@ static int _fortuna_add(unsigned long source, unsigned long pool, const unsigned tmp[0] = (unsigned char)source; tmp[1] = (unsigned char)inlen; - if ((err = sha256_process(&prng->fortuna.pool[pool], tmp, 2)) != CRYPT_OK) { + if ((err = sha256_process(&prng->u.fortuna.pool[pool], tmp, 2)) != CRYPT_OK) { return err; } - if ((err = sha256_process(&prng->fortuna.pool[pool], in, inlen)) != CRYPT_OK) { + if ((err = sha256_process(&prng->u.fortuna.pool[pool], in, inlen)) != CRYPT_OK) { return err; } if (pool == 0) { - prng->fortuna.pool0_len += inlen; + prng->u.fortuna.pool0_len += inlen; } return CRYPT_OK; /* success */ } @@ -320,11 +320,11 @@ int fortuna_add_entropy(const unsigned char *in, unsigned long inlen, prng_state LTC_MUTEX_LOCK(&prng->lock); - err = _fortuna_add(0, prng->fortuna.pool_idx, in, inlen, prng); + err = _fortuna_add(0, prng->u.fortuna.pool_idx, in, inlen, prng); if (err == CRYPT_OK) { - ++(prng->fortuna.pool_idx); - prng->fortuna.pool_idx %= LTC_FORTUNA_POOLS; + ++(prng->u.fortuna.pool_idx); + prng->u.fortuna.pool_idx %= LTC_FORTUNA_POOLS; } LTC_MUTEX_UNLOCK(&prng->lock); @@ -346,9 +346,9 @@ int fortuna_ready(prng_state *prng) /* make sure the reseed doesn't fail because * of the chosen rate limit */ #ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED - prng->fortuna.wd = _fortuna_current_time() - 1; + prng->u.fortuna.wd = _fortuna_current_time() - 1; #else - prng->fortuna.wd = LTC_FORTUNA_WD; + prng->u.fortuna.wd = LTC_FORTUNA_WD; #endif err = _fortuna_reseed(prng); prng->ready = (err == CRYPT_OK) ? 1 : 0; @@ -378,14 +378,14 @@ unsigned long fortuna_read(unsigned char *out, unsigned long outlen, prng_state } /* do we have to reseed? */ - if (prng->fortuna.pool0_len >= 64) { + if (prng->u.fortuna.pool0_len >= 64) { if (_fortuna_reseed(prng) != CRYPT_OK) { goto LBL_UNLOCK; } } /* ensure that one reseed happened before allowing to read */ - if (prng->fortuna.reset_cnt == 0) { + if (prng->u.fortuna.reset_cnt == 0) { goto LBL_UNLOCK; } @@ -395,7 +395,7 @@ unsigned long fortuna_read(unsigned char *out, unsigned long outlen, prng_state /* handle whole blocks without the extra XMEMCPY */ while (outlen >= 16) { /* encrypt the IV and store it */ - rijndael_ecb_encrypt(prng->fortuna.IV, out, &prng->fortuna.skey); + rijndael_ecb_encrypt(prng->u.fortuna.IV, out, &prng->u.fortuna.skey); out += 16; outlen -= 16; _fortuna_update_iv(prng); @@ -403,19 +403,19 @@ unsigned long fortuna_read(unsigned char *out, unsigned long outlen, prng_state /* left over bytes? */ if (outlen > 0) { - rijndael_ecb_encrypt(prng->fortuna.IV, tmp, &prng->fortuna.skey); + rijndael_ecb_encrypt(prng->u.fortuna.IV, tmp, &prng->u.fortuna.skey); XMEMCPY(out, tmp, outlen); _fortuna_update_iv(prng); } /* generate new key */ - rijndael_ecb_encrypt(prng->fortuna.IV, prng->fortuna.K , &prng->fortuna.skey); + rijndael_ecb_encrypt(prng->u.fortuna.IV, prng->u.fortuna.K , &prng->u.fortuna.skey); _fortuna_update_iv(prng); - rijndael_ecb_encrypt(prng->fortuna.IV, prng->fortuna.K+16, &prng->fortuna.skey); + rijndael_ecb_encrypt(prng->u.fortuna.IV, prng->u.fortuna.K+16, &prng->u.fortuna.skey); _fortuna_update_iv(prng); - if (rijndael_setup(prng->fortuna.K, 32, 0, &prng->fortuna.skey) != CRYPT_OK) { + if (rijndael_setup(prng->u.fortuna.K, 32, 0, &prng->u.fortuna.skey) != CRYPT_OK) { tlen = 0; } @@ -444,7 +444,7 @@ int fortuna_done(prng_state *prng) /* terminate all the hashes */ for (x = 0; x < LTC_FORTUNA_POOLS; x++) { - if ((err = sha256_done(&(prng->fortuna.pool[x]), tmp)) != CRYPT_OK) { + if ((err = sha256_done(&(prng->u.fortuna.pool[x]), tmp)) != CRYPT_OK) { goto LBL_UNLOCK; } } diff --git a/src/ltc/prngs/rc4.c b/src/ltc/prngs/rc4.c index 7611151de..ff76fc41b 100644 --- a/src/ltc/prngs/rc4.c +++ b/src/ltc/prngs/rc4.c @@ -39,9 +39,9 @@ int rc4_start(prng_state *prng) LTC_ARGCHK(prng != NULL); prng->ready = 0; /* set entropy (key) size to zero */ - prng->rc4.s.x = 0; + prng->u.rc4.s.x = 0; /* clear entropy (key) buffer */ - XMEMSET(&prng->rc4.s.buf, 0, sizeof(prng->rc4.s.buf)); + XMEMSET(&prng->u.rc4.s.buf, 0, sizeof(prng->u.rc4.s.buf)); LTC_MUTEX_INIT(&prng->lock) return CRYPT_OK; } @@ -66,17 +66,17 @@ int rc4_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *pr LTC_MUTEX_LOCK(&prng->lock); if (prng->ready) { /* rc4_ready() was already called, do "rekey" operation */ - if ((err = rc4_stream_keystream(&prng->rc4.s, buf, sizeof(buf))) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = rc4_stream_keystream(&prng->u.rc4.s, buf, sizeof(buf))) != CRYPT_OK) goto LBL_UNLOCK; for(i = 0; i < inlen; i++) buf[i % sizeof(buf)] ^= in[i]; /* initialize RC4 */ - if ((err = rc4_stream_setup(&prng->rc4.s, buf, sizeof(buf))) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = rc4_stream_setup(&prng->u.rc4.s, buf, sizeof(buf))) != CRYPT_OK) goto LBL_UNLOCK; /* drop first 3072 bytes - https://en.wikipedia.org/wiki/RC4#Fluhrer.2C_Mantin_and_Shamir_attack */ - for (i = 0; i < 12; i++) rc4_stream_keystream(&prng->rc4.s, buf, sizeof(buf)); + for (i = 0; i < 12; i++) rc4_stream_keystream(&prng->u.rc4.s, buf, sizeof(buf)); zeromem(buf, sizeof(buf)); } else { /* rc4_ready() was not called yet, add entropy to the buffer */ - while (inlen--) prng->rc4.s.buf[prng->rc4.s.x++ % sizeof(prng->rc4.s.buf)] ^= *in++; + while (inlen--) prng->u.rc4.s.buf[prng->u.rc4.s.x++ % sizeof(prng->u.rc4.s.buf)] ^= *in++; } err = CRYPT_OK; LBL_UNLOCK: @@ -99,12 +99,12 @@ int rc4_ready(prng_state *prng) LTC_MUTEX_LOCK(&prng->lock); if (prng->ready) { err = CRYPT_OK; goto LBL_UNLOCK; } - XMEMCPY(buf, prng->rc4.s.buf, sizeof(buf)); + XMEMCPY(buf, prng->u.rc4.s.buf, sizeof(buf)); /* initialize RC4 */ - len = MIN(prng->rc4.s.x, 256); /* TODO: we can perhaps always use all 256 bytes */ - if ((err = rc4_stream_setup(&prng->rc4.s, buf, len)) != CRYPT_OK) goto LBL_UNLOCK; + len = MIN(prng->u.rc4.s.x, 256); /* TODO: we can perhaps always use all 256 bytes */ + if ((err = rc4_stream_setup(&prng->u.rc4.s, buf, len)) != CRYPT_OK) goto LBL_UNLOCK; /* drop first 3072 bytes - https://en.wikipedia.org/wiki/RC4#Fluhrer.2C_Mantin_and_Shamir_attack */ - for (i = 0; i < 12; i++) rc4_stream_keystream(&prng->rc4.s, buf, sizeof(buf)); + for (i = 0; i < 12; i++) rc4_stream_keystream(&prng->u.rc4.s, buf, sizeof(buf)); prng->ready = 1; LBL_UNLOCK: LTC_MUTEX_UNLOCK(&prng->lock); @@ -123,7 +123,7 @@ unsigned long rc4_read(unsigned char *out, unsigned long outlen, prng_state *prn if (outlen == 0 || prng == NULL || out == NULL) return 0; LTC_MUTEX_LOCK(&prng->lock); if (!prng->ready) { outlen = 0; goto LBL_UNLOCK; } - if (rc4_stream_keystream(&prng->rc4.s, out, outlen) != CRYPT_OK) outlen = 0; + if (rc4_stream_keystream(&prng->u.rc4.s, out, outlen) != CRYPT_OK) outlen = 0; LBL_UNLOCK: LTC_MUTEX_UNLOCK(&prng->lock); return outlen; @@ -140,7 +140,7 @@ int rc4_done(prng_state *prng) LTC_ARGCHK(prng != NULL); LTC_MUTEX_LOCK(&prng->lock); prng->ready = 0; - err = rc4_stream_done(&prng->rc4.s); + err = rc4_stream_done(&prng->u.rc4.s); LTC_MUTEX_UNLOCK(&prng->lock); LTC_MUTEX_DESTROY(&prng->lock); return err; diff --git a/src/ltc/prngs/sober128.c b/src/ltc/prngs/sober128.c index 951365952..d0a0bb9c5 100644 --- a/src/ltc/prngs/sober128.c +++ b/src/ltc/prngs/sober128.c @@ -40,8 +40,8 @@ int sober128_start(prng_state *prng) { LTC_ARGCHK(prng != NULL); prng->ready = 0; - XMEMSET(&prng->sober128.ent, 0, sizeof(prng->sober128.ent)); - prng->sober128.idx = 0; + XMEMSET(&prng->u.sober128.ent, 0, sizeof(prng->u.sober128.ent)); + prng->u.sober128.idx = 0; LTC_MUTEX_INIT(&prng->lock) return CRYPT_OK; } @@ -66,18 +66,18 @@ int sober128_add_entropy(const unsigned char *in, unsigned long inlen, prng_stat LTC_MUTEX_LOCK(&prng->lock); if (prng->ready) { /* sober128_ready() was already called, do "rekey" operation */ - if ((err = sober128_stream_keystream(&prng->sober128.s, buf, sizeof(buf))) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = sober128_stream_keystream(&prng->u.sober128.s, buf, sizeof(buf))) != CRYPT_OK) goto LBL_UNLOCK; for(i = 0; i < inlen; i++) buf[i % sizeof(buf)] ^= in[i]; /* key 32 bytes, 20 rounds */ - if ((err = sober128_stream_setup(&prng->sober128.s, buf, 32)) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = sober128_stream_setup(&prng->u.sober128.s, buf, 32)) != CRYPT_OK) goto LBL_UNLOCK; /* iv 8 bytes */ - if ((err = sober128_stream_setiv(&prng->sober128.s, buf + 32, 8)) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = sober128_stream_setiv(&prng->u.sober128.s, buf + 32, 8)) != CRYPT_OK) goto LBL_UNLOCK; /* clear KEY + IV */ zeromem(buf, sizeof(buf)); } else { /* sober128_ready() was not called yet, add entropy to ent buffer */ - while (inlen--) prng->sober128.ent[prng->sober128.idx++ % sizeof(prng->sober128.ent)] ^= *in++; + while (inlen--) prng->u.sober128.ent[prng->u.sober128.idx++ % sizeof(prng->u.sober128.ent)] ^= *in++; } err = CRYPT_OK; LBL_UNLOCK: @@ -99,11 +99,11 @@ int sober128_ready(prng_state *prng) LTC_MUTEX_LOCK(&prng->lock); if (prng->ready) { err = CRYPT_OK; goto LBL_UNLOCK; } /* key 32 bytes, 20 rounds */ - if ((err = sober128_stream_setup(&prng->sober128.s, prng->sober128.ent, 32)) != CRYPT_OK) goto LBL_UNLOCK; + if ((err = sober128_stream_setup(&prng->u.sober128.s, prng->u.sober128.ent, 32)) != CRYPT_OK) goto LBL_UNLOCK; /* iv 8 bytes */ - if ((err = sober128_stream_setiv(&prng->sober128.s, prng->sober128.ent + 32, 8)) != CRYPT_OK) goto LBL_UNLOCK; - XMEMSET(&prng->sober128.ent, 0, sizeof(prng->sober128.ent)); - prng->sober128.idx = 0; + if ((err = sober128_stream_setiv(&prng->u.sober128.s, prng->u.sober128.ent + 32, 8)) != CRYPT_OK) goto LBL_UNLOCK; + XMEMSET(&prng->u.sober128.ent, 0, sizeof(prng->u.sober128.ent)); + prng->u.sober128.idx = 0; prng->ready = 1; LBL_UNLOCK: LTC_MUTEX_UNLOCK(&prng->lock); @@ -122,7 +122,7 @@ unsigned long sober128_read(unsigned char *out, unsigned long outlen, prng_state if (outlen == 0 || prng == NULL || out == NULL) return 0; LTC_MUTEX_LOCK(&prng->lock); if (!prng->ready) { outlen = 0; goto LBL_UNLOCK; } - if (sober128_stream_keystream(&prng->sober128.s, out, outlen) != CRYPT_OK) outlen = 0; + if (sober128_stream_keystream(&prng->u.sober128.s, out, outlen) != CRYPT_OK) outlen = 0; LBL_UNLOCK: LTC_MUTEX_UNLOCK(&prng->lock); return outlen; @@ -139,7 +139,7 @@ int sober128_done(prng_state *prng) LTC_ARGCHK(prng != NULL); LTC_MUTEX_LOCK(&prng->lock); prng->ready = 0; - err = sober128_stream_done(&prng->sober128.s); + err = sober128_stream_done(&prng->u.sober128.s); LTC_MUTEX_UNLOCK(&prng->lock); LTC_MUTEX_DESTROY(&prng->lock); return err; diff --git a/src/ltc/prngs/yarrow.c b/src/ltc/prngs/yarrow.c index 6b5057f47..31254c349 100644 --- a/src/ltc/prngs/yarrow.c +++ b/src/ltc/prngs/yarrow.c @@ -43,82 +43,82 @@ int yarrow_start(prng_state *prng) /* these are the default hash/cipher combo used */ #ifdef LTC_RIJNDAEL #if LTC_YARROW_AES==0 - prng->yarrow.cipher = register_cipher(&rijndael_enc_desc); + prng->u.yarrow.cipher = register_cipher(&rijndael_enc_desc); #elif LTC_YARROW_AES==1 - prng->yarrow.cipher = register_cipher(&aes_enc_desc); + prng->u.yarrow.cipher = register_cipher(&aes_enc_desc); #elif LTC_YARROW_AES==2 - prng->yarrow.cipher = register_cipher(&rijndael_desc); + prng->u.yarrow.cipher = register_cipher(&rijndael_desc); #elif LTC_YARROW_AES==3 - prng->yarrow.cipher = register_cipher(&aes_desc); + prng->u.yarrow.cipher = register_cipher(&aes_desc); #endif #elif defined(LTC_BLOWFISH) - prng->yarrow.cipher = register_cipher(&blowfish_desc); + prng->u.yarrow.cipher = register_cipher(&blowfish_desc); #elif defined(LTC_TWOFISH) - prng->yarrow.cipher = register_cipher(&twofish_desc); + prng->u.yarrow.cipher = register_cipher(&twofish_desc); #elif defined(LTC_RC6) - prng->yarrow.cipher = register_cipher(&rc6_desc); + prng->u.yarrow.cipher = register_cipher(&rc6_desc); #elif defined(LTC_RC5) - prng->yarrow.cipher = register_cipher(&rc5_desc); + prng->u.yarrow.cipher = register_cipher(&rc5_desc); #elif defined(LTC_SAFERP) - prng->yarrow.cipher = register_cipher(&saferp_desc); + prng->u.yarrow.cipher = register_cipher(&saferp_desc); #elif defined(LTC_RC2) - prng->yarrow.cipher = register_cipher(&rc2_desc); + prng->u.yarrow.cipher = register_cipher(&rc2_desc); #elif defined(LTC_NOEKEON) - prng->yarrow.cipher = register_cipher(&noekeon_desc); + prng->u.yarrow.cipher = register_cipher(&noekeon_desc); #elif defined(LTC_ANUBIS) - prng->yarrow.cipher = register_cipher(&anubis_desc); + prng->u.yarrow.cipher = register_cipher(&anubis_desc); #elif defined(LTC_KSEED) - prng->yarrow.cipher = register_cipher(&kseed_desc); + prng->u.yarrow.cipher = register_cipher(&kseed_desc); #elif defined(LTC_KHAZAD) - prng->yarrow.cipher = register_cipher(&khazad_desc); + prng->u.yarrow.cipher = register_cipher(&khazad_desc); #elif defined(LTC_CAST5) - prng->yarrow.cipher = register_cipher(&cast5_desc); + prng->u.yarrow.cipher = register_cipher(&cast5_desc); #elif defined(LTC_XTEA) - prng->yarrow.cipher = register_cipher(&xtea_desc); + prng->u.yarrow.cipher = register_cipher(&xtea_desc); #elif defined(LTC_SAFER) - prng->yarrow.cipher = register_cipher(&safer_sk128_desc); + prng->u.yarrow.cipher = register_cipher(&safer_sk128_desc); #elif defined(LTC_DES) - prng->yarrow.cipher = register_cipher(&des3_desc); + prng->u.yarrow.cipher = register_cipher(&des3_desc); #else #error LTC_YARROW needs at least one CIPHER #endif - if ((err = cipher_is_valid(prng->yarrow.cipher)) != CRYPT_OK) { + if ((err = cipher_is_valid(prng->u.yarrow.cipher)) != CRYPT_OK) { return err; } #ifdef LTC_SHA256 - prng->yarrow.hash = register_hash(&sha256_desc); + prng->u.yarrow.hash = register_hash(&sha256_desc); #elif defined(LTC_SHA512) - prng->yarrow.hash = register_hash(&sha512_desc); + prng->u.yarrow.hash = register_hash(&sha512_desc); #elif defined(LTC_TIGER) - prng->yarrow.hash = register_hash(&tiger_desc); + prng->u.yarrow.hash = register_hash(&tiger_desc); #elif defined(LTC_SHA1) - prng->yarrow.hash = register_hash(&sha1_desc); + prng->u.yarrow.hash = register_hash(&sha1_desc); #elif defined(LTC_RIPEMD320) - prng->yarrow.hash = register_hash(&rmd320_desc); + prng->u.yarrow.hash = register_hash(&rmd320_desc); #elif defined(LTC_RIPEMD256) - prng->yarrow.hash = register_hash(&rmd256_desc); + prng->u.yarrow.hash = register_hash(&rmd256_desc); #elif defined(LTC_RIPEMD160) - prng->yarrow.hash = register_hash(&rmd160_desc); + prng->u.yarrow.hash = register_hash(&rmd160_desc); #elif defined(LTC_RIPEMD128) - prng->yarrow.hash = register_hash(&rmd128_desc); + prng->u.yarrow.hash = register_hash(&rmd128_desc); #elif defined(LTC_MD5) - prng->yarrow.hash = register_hash(&md5_desc); + prng->u.yarrow.hash = register_hash(&md5_desc); #elif defined(LTC_MD4) - prng->yarrow.hash = register_hash(&md4_desc); + prng->u.yarrow.hash = register_hash(&md4_desc); #elif defined(LTC_MD2) - prng->yarrow.hash = register_hash(&md2_desc); + prng->u.yarrow.hash = register_hash(&md2_desc); #elif defined(LTC_WHIRLPOOL) - prng->yarrow.hash = register_hash(&whirlpool_desc); + prng->u.yarrow.hash = register_hash(&whirlpool_desc); #else #error LTC_YARROW needs at least one HASH #endif - if ((err = hash_is_valid(prng->yarrow.hash)) != CRYPT_OK) { + if ((err = hash_is_valid(prng->u.yarrow.hash)) != CRYPT_OK) { return err; } /* zero the memory used */ - zeromem(prng->yarrow.pool, sizeof(prng->yarrow.pool)); + zeromem(prng->u.yarrow.pool, sizeof(prng->u.yarrow.pool)); LTC_MUTEX_INIT(&prng->lock) return CRYPT_OK; @@ -142,28 +142,28 @@ int yarrow_add_entropy(const unsigned char *in, unsigned long inlen, prng_state LTC_MUTEX_LOCK(&prng->lock); - if ((err = hash_is_valid(prng->yarrow.hash)) != CRYPT_OK) { + if ((err = hash_is_valid(prng->u.yarrow.hash)) != CRYPT_OK) { goto LBL_UNLOCK; } /* start the hash */ - if ((err = hash_descriptor[prng->yarrow.hash].init(&md)) != CRYPT_OK) { + if ((err = hash_descriptor[prng->u.yarrow.hash].init(&md)) != CRYPT_OK) { goto LBL_UNLOCK; } /* hash the current pool */ - if ((err = hash_descriptor[prng->yarrow.hash].process(&md, prng->yarrow.pool, - hash_descriptor[prng->yarrow.hash].hashsize)) != CRYPT_OK) { + if ((err = hash_descriptor[prng->u.yarrow.hash].process(&md, prng->u.yarrow.pool, + hash_descriptor[prng->u.yarrow.hash].hashsize)) != CRYPT_OK) { goto LBL_UNLOCK; } /* add the new entropy */ - if ((err = hash_descriptor[prng->yarrow.hash].process(&md, in, inlen)) != CRYPT_OK) { + if ((err = hash_descriptor[prng->u.yarrow.hash].process(&md, in, inlen)) != CRYPT_OK) { goto LBL_UNLOCK; } /* store result */ - err = hash_descriptor[prng->yarrow.hash].done(&md, prng->yarrow.pool); + err = hash_descriptor[prng->u.yarrow.hash].done(&md, prng->u.yarrow.pool); LBL_UNLOCK: LTC_MUTEX_UNLOCK(&prng->lock); @@ -183,26 +183,26 @@ int yarrow_ready(prng_state *prng) LTC_MUTEX_LOCK(&prng->lock); - if ((err = hash_is_valid(prng->yarrow.hash)) != CRYPT_OK) { + if ((err = hash_is_valid(prng->u.yarrow.hash)) != CRYPT_OK) { goto LBL_UNLOCK; } - if ((err = cipher_is_valid(prng->yarrow.cipher)) != CRYPT_OK) { + if ((err = cipher_is_valid(prng->u.yarrow.cipher)) != CRYPT_OK) { goto LBL_UNLOCK; } /* setup CTR mode using the "pool" as the key */ - ks = (int)hash_descriptor[prng->yarrow.hash].hashsize; - if ((err = cipher_descriptor[prng->yarrow.cipher].keysize(&ks)) != CRYPT_OK) { + ks = (int)hash_descriptor[prng->u.yarrow.hash].hashsize; + if ((err = cipher_descriptor[prng->u.yarrow.cipher].keysize(&ks)) != CRYPT_OK) { goto LBL_UNLOCK; } - if ((err = ctr_start(prng->yarrow.cipher, /* what cipher to use */ - prng->yarrow.pool, /* IV */ - prng->yarrow.pool, ks, /* KEY and key size */ + if ((err = ctr_start(prng->u.yarrow.cipher, /* what cipher to use */ + prng->u.yarrow.pool, /* IV */ + prng->u.yarrow.pool, ks, /* KEY and key size */ 0, /* number of rounds */ CTR_COUNTER_LITTLE_ENDIAN, /* little endian counter */ - &prng->yarrow.ctr)) != CRYPT_OK) { + &prng->u.yarrow.ctr)) != CRYPT_OK) { goto LBL_UNLOCK; } prng->ready = 1; @@ -234,7 +234,7 @@ unsigned long yarrow_read(unsigned char *out, unsigned long outlen, prng_state * zeromem(out, outlen); /* now randomize it */ - if (ctr_encrypt(out, out, outlen, &prng->yarrow.ctr) != CRYPT_OK) { + if (ctr_encrypt(out, out, outlen, &prng->u.yarrow.ctr) != CRYPT_OK) { outlen = 0; } @@ -259,7 +259,7 @@ int yarrow_done(prng_state *prng) /* call cipher done when we invent one ;-) */ /* we invented one */ - err = ctr_done(&prng->yarrow.ctr); + err = ctr_done(&prng->u.yarrow.ctr); LTC_MUTEX_UNLOCK(&prng->lock); LTC_MUTEX_DESTROY(&prng->lock);