Skip to content
Snippets Groups Projects
Select Git revision
  • 18a5be796aa1bf78e0baf5f3d365cbac4a5abcf1
  • master default
  • wip-add-ed25519
  • disable-sha1
  • lsh-2.0.4
  • experimental-20050201
  • lsh-1.4.2
  • lsh-1.2
  • lsh_2.1_release_20130626
  • converted-master-branch-to-git
  • nettle_2.4_release_20110903
  • nettle_2.3_release_20110902
  • nettle_2.2_release_20110711
  • nettle_2.1_release_20100725
  • camellia_32bit_20100720
  • nettle_2.0_release_20090608
  • converted-lsh-2.0.4-branch-to-git
  • lsh_2.0.4_release_20070905
  • lsh_2.9_exp_release_20070404
  • nettle_1.15_release_20061128
  • after_experimental_merge_20060516
  • branch_before_experimental_merge_20060516
  • converted-experimental-branch-to-git
  • head_before_experimental_merge_20060516
  • lsh_2.0.3_release_20060509
  • lsh_2.0.2_release_20060127
  • nettle_1.14_release_20051205
  • nettle_1.13_release_20051006
28 results

randomness.c

Blame
  • randomness.c 1.42 KiB
    /* randomness.c
     *
     */
    
    #include "randomness.h"
    #include "abstract_crypto.h"
    
    /* Random */
    struct poor_random
    {
      struct randomness super;
      struct hash_instance *hash;
      UINT32 pos;
      UINT8 buffer[1];
    };
    
    static void do_poor_random(struct randomness **r, UINT32 length, UINT8 *dst)
    {
      struct poor_random *self = (struct poor_random *) *r;
    
      while(length)
        {
          UINT32 available = self->hash->hash_size - self->pos;
          UINT32 to_copy;
          
          if (!available)
    	{
    	  time_t now = time(NULL); /* To avoid cycles */
    	  HASH_UPDATE(self->hash, sizeof(now), (UINT8 *) &now);
    	  HASH_UPDATE(self->hash, self->hash->hash_size,
    		      self->buffer);
    	  HASH_DIGEST(self->hash, self->buffer);
    
    	  available = self->hash->hash_size;
    	  self->pos = 0;
    	}
          to_copy = MIN(available, length);
    
          memcpy(dst, self->buffer + self->pos, to_copy);
          length -= to_copy;
          dst += to_copy;
          self->pos += to_copy;
        }
    }
    
    struct randomness *make_poor_random(struct hash_algorithm *hash,
    				    struct lsh_string *init)
    {
      struct poor_random *self
        = xalloc(sizeof(struct poor_random) - 1 + hash->hash_size);
      time_t now = time(NULL); /* To avoid cycles */
        
      self->super.random = do_poor_random;
      self->hash = MAKE_HASH(hash);
    
      HASH_UPDATE(self->hash, sizeof(now), (UINT8 *) &now);
      HASH_UPDATE(self->hash, init->length, init->data);
      HASH_DIGEST(self->hash, self->buffer);
      
      self->pos = 0;
    
      return &self->super;
    }