/* Copyright 2003-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * See the paper "???" by Ben Laurie for an explanation of this PRNG. */ #include "apr.h" #include "apr_pools.h" #include "apr_random.h" #include "apr_thread_proc.h" #include #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; 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) 1 { 1 unsigned int n; 1 g->apr_pool = p; 1 g->pool_hash = pool_hash; 1 g->key_hash = key_hash; 1 g->prng_hash = prng_hash; 1 g->npools = APR_RANDOM_DEFAULT_POOLS; 1 g->pools = apr_palloc(p,g->npools*sizeof *g->pools); 33 for (n = 0; n < g->npools; ++n) { 32 g->pools[n].bytes = g->pools[n].pool_size = 0; 32 g->pools[n].pool = NULL; } 1 g->next_pool = 0; 1 g->generation = 0; 1 g->rehash_size = APR_RANDOM_DEFAULT_REHASH_SIZE; /* Ensure that the rehash size is twice the size of the pool hasher */ 1 g->rehash_size = ((g->rehash_size+2*g->pool_hash->size-1)/g->pool_hash->size /2)*g->pool_hash->size*2; 1 g->reseed_size = APR_RANDOM_DEFAULT_RESEED_SIZE; 1 g->H = apr_palloc(p,H_size(g)); 1 g->H_waiting = apr_palloc(p,H_size(g)); 1 g->randomness = apr_palloc(p,B_size(g)); 1 g->random_bytes = 0; 1 g->g_for_insecure = APR_RANDOM_DEFAULT_G_FOR_INSECURE; 1 g->secure_base = 0; 1 g->g_for_secure = APR_RANDOM_DEFAULT_G_FOR_SECURE; 1 g->secure_started = g->insecure_started = 0; 1 g->next = all_random; 1 all_random = g; } static void mix_pid(apr_random_t *g,unsigned char *H,pid_t pid) 2 { 2 hash_init(g->key_hash); 2 hash_add(g->key_hash,H,H_size(g)); 2 hash_add(g->key_hash,&pid,sizeof pid); 2 hash_finish(g->key_hash,H); } static void mixer(apr_random_t *g,pid_t pid) 2 { 2 unsigned char *H = H_current(g); /* mix the PID into the current H */ 2 mix_pid(g,H,pid); /* if we are in waiting, then also mix into main H */ 2 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 */ 2 --g->generation; /* blow away any lingering randomness */ 2 g->random_bytes = 0; } APR_DECLARE(void) apr_random_after_fork(apr_proc_t *proc) 8 { 8 apr_random_t *r; 10 for (r = all_random; r; r = r->next) 2 mixer(r,proc->pid); } APR_DECLARE(apr_random_t *) apr_random_standard_new(apr_pool_t *p) 1 { 1 apr_random_t *r = apr_palloc(p,sizeof *r); 1 apr_random_init(r,p,apr_crypto_sha256_new(p),apr_crypto_sha256_new(p), apr_crypto_sha256_new(p)); 1 return r; } static void rekey(apr_random_t *g) 675 { 675 unsigned int n; 675 unsigned char *H = H_current(g); 675 hash_init(g->key_hash); 675 hash_add(g->key_hash,H,H_size(g)); 2020 for (n = 0 ; n < g->npools && (n == 0 || g->generation&(1 << (n-1))) ; ++n) { 1345 hash_add(g->key_hash,g->pools[n].pool,g->pools[n].bytes); 1345 g->pools[n].bytes = 0; } 675 hash_finish(g->key_hash,H+B_size(g)); 675 ++g->generation; 675 if (!g->insecure_started && g->generation > g->g_for_insecure) { 1 g->insecure_started = 1; 1 if (!g->secure_started) { 1 memcpy(g->H_waiting,g->H,H_size(g)); 1 g->secure_base = g->generation; } } 675 if (!g->secure_started && g->generation > g->secure_base+g->g_for_secure) { 2 g->secure_started = 1; 2 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) 675 { 675 unsigned int n; 675 const unsigned char *entropy = entropy_; 1383075 for (n = 0; n < bytes; ++n) { 1382400 apr_random_pool_t *p = &g->pools[g->next_pool]; 1382400 if (++g->next_pool == g->npools) 43200 g->next_pool = 0; 1382400 if (p->pool_size < p->bytes+1) { 310 unsigned char *np = apr_palloc(g->apr_pool,(p->bytes+1)*2); 310 memcpy(np,p->pool,p->bytes); 310 p->pool = np; 310 p->pool_size = (p->bytes+1)*2; } 1382400 p->pool[p->bytes++] = entropy[n]; 1382400 if (p->bytes == g->rehash_size) { 2245 unsigned int r; 38165 for (r = 0; r < p->bytes/2; r+=g->pool_hash->size) 35920 hash(g->pool_hash,p->pool+r,p->pool+r*2,g->pool_hash->size*2); 2245 p->bytes/=2; } 1382400 assert(p->bytes < g->rehash_size); } 675 if (g->pools[0].bytes >= g->reseed_size) 675 rekey(g); } /* This will give g->B_size bytes of randomness */ static void apr_random_block(apr_random_t *g,unsigned char *random) 24 { /* FIXME: in principle, these are different hashes */ 24 hash(g->prng_hash,g->H,g->H,H_size(g)); 24 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) 6 { 6 apr_size_t n; 30 for (n = 0; n < bytes; ) { 24 int l; 24 if (g->random_bytes == 0) { 24 apr_random_block(g,g->randomness); 24 g->random_bytes = B_size(g); } 24 l = min(bytes-n,g->random_bytes); 24 memcpy(&random[n],g->randomness+B_size(g)-g->random_bytes,l); 24 g->random_bytes-=l; 24 n+=l; } } APR_DECLARE(apr_status_t) apr_random_secure_bytes(apr_random_t *g, void *random, apr_size_t bytes) 6 { 6 if (!g->secure_started) 2 return APR_ENOTENOUGHENTROPY; 4 apr_random_bytes(g,random,bytes); 4 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_random_insecure_bytes(apr_random_t *g, void *random, apr_size_t bytes) 3 { 3 if (!g->insecure_started) 1 return APR_ENOTENOUGHENTROPY; 2 apr_random_bytes(g,random,bytes); 2 return APR_SUCCESS; } APR_DECLARE(void) apr_random_barrier(apr_random_t *g) 1 { 1 g->secure_started = 0; 1 g->secure_base = g->generation; } APR_DECLARE(apr_status_t) apr_random_secure_ready(apr_random_t *r) ###### { ###### if (!r->secure_started) ###### return APR_ENOTENOUGHENTROPY; ###### return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_random_insecure_ready(apr_random_t *r) ###### { ###### if (!r->insecure_started) ###### return APR_ENOTENOUGHENTROPY; ###### return APR_SUCCESS; }