Skip to content
Snippets Groups Projects
Select Git revision
  • 29cdaf1189eab3ca59e7e3b31b893f9903490845
  • master default protected
  • siv-mode
  • delete-des-compat
  • delete-rsa_blind
  • aes-struct-layout
  • master-updates
  • release-3.4-fixes
  • struct-layout
  • attribute-deprecated
  • rename-data-symbols
  • x86_64-sha_ni-sha256
  • ecc-params-tweak
  • delete-old-aes
  • cmac-support
  • x86_64-sha_ni-sha1
  • gcm-ctr-opt
  • ctr-opt
  • skein
  • api-opaque-fix
  • curve448
  • nettle_3.4.1_release_20181204
  • nettle_3.4.1rc1
  • nettle_3.4_release_20171119
  • nettle_3.4rc2
  • nettle_3.4rc1
  • nettle_3.3_release_20161001
  • nettle_3.2_release_20160128
  • nettle_3.1.1_release_20150424
  • nettle_3.1_release_20150407
  • nettle_3.1rc3
  • nettle_3.1rc2
  • nettle_3.1rc1
  • nettle_3.0_release_20140607
  • nettle_2.7.1_release_20130528
  • nettle_2.7_release_20130424
  • nettle_2.6_release_20130116
  • nettle_2.5_release_20120707
  • converted-master-branch-to-git
  • nettle_2.4_release_20110903
  • nettle_2.3_release_20110902
41 results

timing.h

Blame
  • Forked from Nettle / nettle
    Source project has a limited visibility.
    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;
    }