Author: cem Date: Thu Jan 30 18:12:41 2020 New Revision: 357301 URL: https://svnweb.freebsd.org/changeset/base/357301
Log: contrib/apr: Rip out bogus [CS]PRNG implementation This construction used some relatively slow design involving SHA2; even if it were fed real entropy (unclear; external to the design), it did not handle fork in a safe way, and it was difficult to audit for correctness. So just rip it out and use the very simple and known-correct arc4random(3) interface in its place. Modified: head/contrib/apr/random/unix/apr_random.c Modified: head/contrib/apr/random/unix/apr_random.c ============================================================================== --- head/contrib/apr/random/unix/apr_random.c Thu Jan 30 18:12:24 2020 (r357300) +++ head/contrib/apr/random/unix/apr_random.c Thu Jan 30 18:12:41 2020 (r357301) @@ -13,285 +13,51 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/* - * See the paper "On Randomness" by Ben Laurie for an explanation of this PRNG. - * http://www.apache-ssl.org/randomness.pdf - * XXX: Is there a formal proof of this PRNG? Couldn't we use the more popular - * Mersenne Twister PRNG (and BSD licensed)? - */ #include "apr.h" #include "apr_pools.h" #include "apr_random.h" #include "apr_thread_proc.h" #include <assert.h> +#include <stdlib.h> -#ifdef min -#undef min -#endif -#define min(a,b) ((a) < (b) ? (a) : (b)) - -#define APR_RANDOM_DEFAULT_POOLS 32 -#define APR_RANDOM_DEFAULT_REHASH_SIZE 1024 -#define APR_RANDOM_DEFAULT_RESEED_SIZE 32 -#define APR_RANDOM_DEFAULT_HASH_SECRET_SIZE 32 -#define APR_RANDOM_DEFAULT_G_FOR_INSECURE 32 -#define APR_RANDOM_DEFAULT_G_FOR_SECURE 320 - -typedef struct apr_random_pool_t { - unsigned char *pool; - unsigned int bytes; - unsigned int pool_size; -} apr_random_pool_t; - -#define hash_init(h) (h)->init(h) -#define hash_add(h,b,n) (h)->add(h,b,n) -#define hash_finish(h,r) (h)->finish(h,r) - -#define hash(h,r,b,n) hash_init(h),hash_add(h,b,n),hash_finish(h,r) - -#define crypt_setkey(c,k) (c)->set_key((c)->data,k) -#define crypt_crypt(c,out,in) (c)->crypt((c)->date,out,in) - -struct apr_random_t { - apr_pool_t *apr_pool; - apr_crypto_hash_t *pool_hash; - unsigned int npools; - apr_random_pool_t *pools; - unsigned int next_pool; - unsigned int generation; - apr_size_t rehash_size; - apr_size_t reseed_size; - apr_crypto_hash_t *key_hash; -#define K_size(g) ((g)->key_hash->size) - apr_crypto_hash_t *prng_hash; -#define B_size(g) ((g)->prng_hash->size) - - unsigned char *H; - unsigned char *H_waiting; -#define H_size(g) (B_size(g)+K_size(g)) -#define H_current(g) (((g)->insecure_started && !(g)->secure_started) \ - ? (g)->H_waiting : (g)->H) - - unsigned char *randomness; - apr_size_t random_bytes; - unsigned int g_for_insecure; - unsigned int g_for_secure; - unsigned int secure_base; - unsigned int insecure_started:1; - unsigned int secure_started:1; - - apr_random_t *next; -}; - -static apr_random_t *all_random; - -static apr_status_t random_cleanup(void *data) -{ - apr_random_t *remove_this = data, - *cur = all_random, - **prev_ptr = &all_random; - while (cur) { - if (cur == remove_this) { - *prev_ptr = cur->next; - break; - } - prev_ptr = &cur->next; - cur = cur->next; - } - return APR_SUCCESS; -} - - APR_DECLARE(void) apr_random_init(apr_random_t *g,apr_pool_t *p, apr_crypto_hash_t *pool_hash, apr_crypto_hash_t *key_hash, apr_crypto_hash_t *prng_hash) { - unsigned int n; - - g->apr_pool = p; - - g->pool_hash = pool_hash; - g->key_hash = key_hash; - g->prng_hash = prng_hash; - - g->npools = APR_RANDOM_DEFAULT_POOLS; - g->pools = apr_palloc(p,g->npools*sizeof *g->pools); - for (n = 0; n < g->npools; ++n) { - g->pools[n].bytes = g->pools[n].pool_size = 0; - g->pools[n].pool = NULL; - } - g->next_pool = 0; - - g->generation = 0; - - g->rehash_size = APR_RANDOM_DEFAULT_REHASH_SIZE; - /* Ensure that the rehash size is twice the size of the pool hasher */ - g->rehash_size = ((g->rehash_size+2*g->pool_hash->size-1)/g->pool_hash->size - /2)*g->pool_hash->size*2; - g->reseed_size = APR_RANDOM_DEFAULT_RESEED_SIZE; - - g->H = apr_pcalloc(p,H_size(g)); - g->H_waiting = apr_pcalloc(p,H_size(g)); - - g->randomness = apr_palloc(p,B_size(g)); - g->random_bytes = 0; - - g->g_for_insecure = APR_RANDOM_DEFAULT_G_FOR_INSECURE; - g->secure_base = 0; - g->g_for_secure = APR_RANDOM_DEFAULT_G_FOR_SECURE; - g->secure_started = g->insecure_started = 0; - - g->next = all_random; - all_random = g; - apr_pool_cleanup_register(p, g, random_cleanup, apr_pool_cleanup_null); + (void)g; + (void)p; + (void)pool_hash; + (void)key_hash; + (void)prng_hash; } -static void mix_pid(apr_random_t *g,unsigned char *H,pid_t pid) -{ - hash_init(g->key_hash); - hash_add(g->key_hash,H,H_size(g)); - hash_add(g->key_hash,&pid,sizeof pid); - hash_finish(g->key_hash,H); -} - -static void mixer(apr_random_t *g,pid_t pid) -{ - unsigned char *H = H_current(g); - - /* mix the PID into the current H */ - mix_pid(g,H,pid); - /* if we are in waiting, then also mix into main H */ - if (H != g->H) - mix_pid(g,g->H,pid); - /* change order of pool mixing for good measure - note that going - backwards is much better than going forwards */ - --g->generation; - /* blow away any lingering randomness */ - g->random_bytes = 0; -} - APR_DECLARE(void) apr_random_after_fork(apr_proc_t *proc) { - apr_random_t *r; - - for (r = all_random; r; r = r->next) - /* - * XXX Note: the pid does not provide sufficient entropy to - * actually call this secure. See Ben's paper referenced at - * the top of this file. - */ - mixer(r,proc->pid); + (void)proc; } APR_DECLARE(apr_random_t *) apr_random_standard_new(apr_pool_t *p) { - apr_random_t *r = apr_palloc(p,sizeof *r); - - apr_random_init(r,p,apr_crypto_sha256_new(p),apr_crypto_sha256_new(p), - apr_crypto_sha256_new(p)); - return r; + /* apr_random_t is an opaque struct type. */ + return (void *)0x1; } -static void rekey(apr_random_t *g) -{ - unsigned int n; - unsigned char *H = H_current(g); - - hash_init(g->key_hash); - hash_add(g->key_hash,H,H_size(g)); - for (n = 0 ; n < g->npools && (n == 0 || g->generation&(1 << (n-1))) - ; ++n) { - hash_add(g->key_hash,g->pools[n].pool,g->pools[n].bytes); - g->pools[n].bytes = 0; - } - hash_finish(g->key_hash,H+B_size(g)); - - ++g->generation; - if (!g->insecure_started && g->generation > g->g_for_insecure) { - g->insecure_started = 1; - if (!g->secure_started) { - memcpy(g->H_waiting,g->H,H_size(g)); - g->secure_base = g->generation; - } - } - - if (!g->secure_started && g->generation > g->secure_base+g->g_for_secure) { - g->secure_started = 1; - memcpy(g->H,g->H_waiting,H_size(g)); - } -} - APR_DECLARE(void) apr_random_add_entropy(apr_random_t *g,const void *entropy_, apr_size_t bytes) { - unsigned int n; - const unsigned char *entropy = entropy_; - - for (n = 0; n < bytes; ++n) { - apr_random_pool_t *p = &g->pools[g->next_pool]; - - if (++g->next_pool == g->npools) - g->next_pool = 0; - - if (p->pool_size < p->bytes+1) { - unsigned char *np = apr_palloc(g->apr_pool,(p->bytes+1)*2); - - memcpy(np,p->pool,p->bytes); - p->pool = np; - p->pool_size = (p->bytes+1)*2; - } - p->pool[p->bytes++] = entropy[n]; - - if (p->bytes == g->rehash_size) { - apr_size_t r; - - for (r = 0; r < p->bytes/2; r+=g->pool_hash->size) - hash(g->pool_hash,p->pool+r,p->pool+r*2,g->pool_hash->size*2); - p->bytes/=2; - } - assert(p->bytes < g->rehash_size); - } - - if (g->pools[0].bytes >= g->reseed_size) - rekey(g); + (void)g; + (void)entropy_; + (void)bytes; } -/* This will give g->B_size bytes of randomness */ -static void apr_random_block(apr_random_t *g,unsigned char *random) -{ - /* FIXME: in principle, these are different hashes */ - hash(g->prng_hash,g->H,g->H,H_size(g)); - hash(g->prng_hash,random,g->H,B_size(g)); -} - -static void apr_random_bytes(apr_random_t *g,unsigned char *random, - apr_size_t bytes) -{ - apr_size_t n; - - for (n = 0; n < bytes; ) { - apr_size_t l; - - if (g->random_bytes == 0) { - apr_random_block(g,g->randomness); - g->random_bytes = B_size(g); - } - l = min(bytes-n,g->random_bytes); - memcpy(&random[n],g->randomness+B_size(g)-g->random_bytes,l); - g->random_bytes-=l; - n+=l; - } -} - APR_DECLARE(apr_status_t) apr_random_secure_bytes(apr_random_t *g, void *random, apr_size_t bytes) { - if (!g->secure_started) - return APR_ENOTENOUGHENTROPY; - apr_random_bytes(g,random,bytes); + (void)g; + arc4random_buf(random, bytes); return APR_SUCCESS; } @@ -299,28 +65,24 @@ APR_DECLARE(apr_status_t) apr_random_insecure_bytes(ap void *random, apr_size_t bytes) { - if (!g->insecure_started) - return APR_ENOTENOUGHENTROPY; - apr_random_bytes(g,random,bytes); + (void)g; + arc4random_buf(random, bytes); return APR_SUCCESS; } APR_DECLARE(void) apr_random_barrier(apr_random_t *g) { - g->secure_started = 0; - g->secure_base = g->generation; + (void)g; } APR_DECLARE(apr_status_t) apr_random_secure_ready(apr_random_t *r) { - if (!r->secure_started) - return APR_ENOTENOUGHENTROPY; + (void)r; return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_random_insecure_ready(apr_random_t *r) { - if (!r->insecure_started) - return APR_ENOTENOUGHENTROPY; + (void)r; return APR_SUCCESS; } _______________________________________________ svn-src-all@freebsd.org mailing list https://lists.freebsd.org/mailman/listinfo/svn-src-all To unsubscribe, send any mail to "svn-src-all-unsubscr...@freebsd.org"