コード例 #1
0
ファイル: t-lock.c プロジェクト: Distrotech/libgpg-error
/* This is one of our accountants.  */
static THREAD_RET_TYPE
accountant_thread (void *arg)
{
  gpg_err_code_t rc;
  int i;
  int acc1, acc2;
  int value;

  (void)arg;

#ifdef _WIN32
  srand (time(NULL)*getpid());  /* Windows needs it per thread.  */
#endif
  for (i = 0; i < N_TRANSACTIONS; i++)
    {
      rc = gpgrt_lock_lock (&accounts_lock);
      if (rc)
        fail ("gpgrt_lock_lock failed at %d: %s", __LINE__, gpg_strerror (rc));

      acc1 = pick_account ();
      acc2 = pick_account ();
      value = pick_value ();
      account[acc1] += value;
      account[acc2] -= value;

      rc = gpgrt_lock_unlock (&accounts_lock);
      if (rc)
        fail ("gpgrt_lock_unlock failed at %d: %s", __LINE__,gpg_strerror (rc));
      if (i && !(i%8))
        gpgrt_yield ();
    }
  return THREAD_RET_VALUE;
}
コード例 #2
0
ファイル: random-csprng.c プロジェクト: OneSecure/libgcrypt
/* Release the pool lock. */
static void
unlock_pool (void)
{
  int err;

  pool_is_locked = 0;
  err = gpgrt_lock_unlock (&pool_lock);
  if (err)
    log_fatal ("failed to release the pool lock: %s\n", gpg_strerror (err));
}
コード例 #3
0
ファイル: random-system.c プロジェクト: Distrotech/libgcrypt
/* Release the system_rng_lock.  */
static void
unlock_rng (void)
{
  gpg_err_code_t rc;

  system_rng_is_locked = 0;
  rc = gpgrt_lock_unlock (&system_rng_lock);
  if (rc)
    log_fatal ("failed to release the System RNG lock: %s\n",
               gpg_strerror (rc));
}
コード例 #4
0
ファイル: fips.c プロジェクト: ShiftMediaProject/libgcrypt
static void
unlock_fsm (void)
{
  gpg_error_t err;

  err = gpgrt_lock_unlock (&fsm_lock);
  if (err)
    {
      log_info ("FATAL: failed to release the FSM lock in libgrypt: %s\n",
                gpg_strerror (err));
#ifdef HAVE_SYSLOG
      syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
              "releasing FSM lock failed: %s - abort",
              gpg_strerror (err));
#endif /*HAVE_SYSLOG*/
      abort ();
    }
}
コード例 #5
0
ファイル: t-lock.c プロジェクト: Distrotech/libgpg-error
/* This is the revision department.  */
static THREAD_RET_TYPE
revision_thread (void *arg)
{
  gpg_err_code_t rc;
  int i = 0;

  (void)arg;

  while (!stop_revision_thread)
    {
      rc = gpgrt_lock_lock (&accounts_lock);
      if (rc)
        fail ("gpgrt_lock_lock failed at %d: %s", __LINE__, gpg_strerror (rc));

      check_accounts ();
      rc = gpgrt_lock_unlock (&accounts_lock);
      if (rc)
        fail ("gpgrt_lock_unlock failed at %d: %s", __LINE__,gpg_strerror (rc));
      if (!(++i%7))
        gpgrt_yield ();
    }
  return THREAD_RET_VALUE;
}
コード例 #6
0
ファイル: random.c プロジェクト: Distrotech/libgcrypt
/* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
void
_gcry_create_nonce (void *buffer, size_t length)
{
  static unsigned char nonce_buffer[20+8];
  static int nonce_buffer_initialized = 0;
  static volatile pid_t my_pid; /* The volatile is there to make sure the
                                   compiler does not optimize the code away
                                   in case the getpid function is badly
                                   attributed. */
  volatile pid_t apid;
  unsigned char *p;
  size_t n;
  int err;

  /* First check whether we shall use the FIPS nonce generator.  This
     is only done in FIPS mode, in all other modes, we use our own
     nonce generator which is seeded by the RNG actual in use.  */
  if (fips_mode ())
    {
      _gcry_rngfips_create_nonce (buffer, length);
      return;
    }

  /* This is the nonce generator, which formerly lived in
     random-csprng.c.  It is now used by all RNG types except when in
     FIPS mode (not that this means it is also used if the FIPS RNG
     has been selected but we are not in fips mode).  */

  /* Make sure we are initialized. */
  _gcry_random_initialize (1);

  /* Acquire the nonce buffer lock. */
  err = gpgrt_lock_lock (&nonce_buffer_lock);
  if (err)
    log_fatal ("failed to acquire the nonce buffer lock: %s\n",
               gpg_strerror (err));

  apid = getpid ();
  /* The first time initialize our buffer. */
  if (!nonce_buffer_initialized)
    {
      time_t atime = time (NULL);
      pid_t xpid = apid;

      my_pid = apid;

      if ((sizeof apid + sizeof atime) > sizeof nonce_buffer)
        BUG ();

      /* Initialize the first 20 bytes with a reasonable value so that
         a failure of gcry_randomize won't affect us too much.  Don't
         care about the uninitialized remaining bytes. */
      p = nonce_buffer;
      memcpy (p, &xpid, sizeof xpid);
      p += sizeof xpid;
      memcpy (p, &atime, sizeof atime);

      /* Initialize the never changing private part of 64 bits. */
      _gcry_randomize (nonce_buffer+20, 8, GCRY_WEAK_RANDOM);

      nonce_buffer_initialized = 1;
    }
  else if ( my_pid != apid )
    {
      /* We forked. Need to reseed the buffer - doing this for the
         private part should be sufficient. */
      do_randomize (nonce_buffer+20, 8, GCRY_WEAK_RANDOM);
      /* Update the pid so that we won't run into here again and
         again. */
      my_pid = apid;
    }

  /* Create the nonce by hashing the entire buffer, returning the hash
     and updating the first 20 bytes of the buffer with this hash. */
  for (p = buffer; length > 0; length -= n, p += n)
    {
      _gcry_sha1_hash_buffer (nonce_buffer,
                              nonce_buffer, sizeof nonce_buffer);
      n = length > 20? 20 : length;
      memcpy (p, nonce_buffer, n);
    }

  /* Release the nonce buffer lock. */
  err = gpgrt_lock_unlock (&nonce_buffer_lock);
  if (err)
    log_fatal ("failed to release the nonce buffer lock: %s\n",
               gpg_strerror (err));
}