* LOCKING
*
* The three shared DRBGs are intended to be used concurrently, so they
- * support locking by default. It is the callers responsibility to wrap
- * calls to functions like RAND_DRBG_generate() which modify the DRBGs
- * internal state with calls to RAND_DRBG_lock() and RAND_DRBG_unlock().
- * The functions RAND_bytes() and RAND_priv_bytes() take the locks
- * automatically, so using the RAND api is thread safe as before.
- *
- * All other DRBG instances don't have locking enabled by default, because
- * they are intendended to be used by a single thread. If it is desired,
- * locking can be enabled using RAND_DRBG_enable_locking(). However, instead
- * of accessing a single DRBG instance concurrently from different threads,
- * it is recommended to instantiate a separate DRBG instance per thread.
+ * support locking. The RAND methods take the locks automatically, so using
+ * the RAND api (in particular RAND_bytes() and RAND_priv_bytes()) is
+ * thread-safe. Note however that accessing the shared DRBGs directly via
+ * the RAND_DRBG interface is *not* thread-safe.
+ *
+ * All other DRBG instances don't support locking, because they are
+ * intendended to be used by a single thread. Instead of accessing a single
+ * DRBG instance concurrently from different threads, it is recommended to
+ * instantiate a separate DRBG instance per thread. Using the same shared
+ * DRBG (preferrably the public DRBG) as parent of DRBG instances on
+ * different threads is safe.
*/
*
* Returns 1 on success, 0 on failure.
*/
-int RAND_DRBG_lock(RAND_DRBG *drbg)
+int rand_drbg_lock(RAND_DRBG *drbg)
{
if (drbg->lock != NULL)
return CRYPTO_THREAD_write_lock(drbg->lock);
*
* Returns 1 on success, 0 on failure.
*/
-int RAND_DRBG_unlock(RAND_DRBG *drbg)
+int rand_drbg_unlock(RAND_DRBG *drbg)
{
if (drbg->lock != NULL)
return CRYPTO_THREAD_unlock(drbg->lock);
*
* Returns 1 on success, 0 on failure.
*/
-int RAND_DRBG_enable_locking(RAND_DRBG *drbg)
+int rand_drbg_enable_locking(RAND_DRBG *drbg)
{
if (drbg->state != DRBG_UNINITIALISED) {
RANDerr(RAND_F_RAND_DRBG_ENABLE_LOCKING,
{
RAND_DRBG *drbg;
- drbg = RAND_DRBG_secure_new(RAND_DRBG_NID, RAND_DRBG_FLAG_CTR_USE_DF, parent);
+ drbg = RAND_DRBG_secure_new(RAND_DRBG_NID, 0, parent);
if (drbg == NULL)
return NULL;
- if (RAND_DRBG_enable_locking(drbg) == 0)
+ if (rand_drbg_enable_locking(drbg) == 0)
goto err;
if (parent == NULL) {
if (drbg == NULL)
return 0;
- RAND_DRBG_lock(drbg);
+ rand_drbg_lock(drbg);
ret = RAND_DRBG_bytes(drbg, out, count);
- RAND_DRBG_unlock(drbg);
+ rand_drbg_unlock(drbg);
return ret;
}
return 0;
}
- RAND_DRBG_lock(drbg);
+ rand_drbg_lock(drbg);
ret = rand_drbg_restart(drbg, buf,
(size_t)(unsigned int)num,
(size_t)(8*randomness));
- RAND_DRBG_unlock(drbg);
+ rand_drbg_unlock(drbg);
return ret;
}
if (drbg == NULL)
return 0;
- RAND_DRBG_lock(drbg);
+ rand_drbg_lock(drbg);
ret = drbg->state == DRBG_READY ? 1 : 0;
- RAND_DRBG_unlock(drbg);
+ rand_drbg_unlock(drbg);
return ret;
}