dctx->flags = flags;
dctx->type = type;
+ dctx->health_check_cnt = 0;
+ dctx->health_check_interval = DRBG_HEALTH_INTERVAL;
+
rv = fips_drbg_hash_init(dctx);
if (rv == -2)
FIPSerr(FIPS_F_FIPS_DRBG_INIT, FIPS_R_ERROR_INITIALISING_DRBG);
}
+ /* If not in test mode run selftests on DRBG of the same type */
+
+ if (!(dctx->flags & DRBG_FLAG_TEST))
+ {
+ DRBG_CTX tctx;
+ if (!fips_drbg_kat(&tctx, type, flags | DRBG_FLAG_TEST))
+ {
+ FIPSerr(FIPS_F_FIPS_DRBG_INIT, FIPS_R_SELFTEST_FAILURE);
+ return 0;
+ }
+ }
+
return rv;
}
DRBG_CTX *FIPS_drbg_new(int type, unsigned int flags)
{
- int rv;
DRBG_CTX *dctx;
dctx = OPENSSL_malloc(sizeof(DRBG_CTX));
if (!dctx)
}
if (type == 0)
return dctx;
- rv = FIPS_drbg_init(dctx, type, flags);
if (FIPS_drbg_init(dctx, type, flags) <= 0)
{
{
if (dctx->uninstantiate)
dctx->uninstantiate(dctx);
- OPENSSL_cleanse(dctx, sizeof(DRBG_CTX));
+ OPENSSL_cleanse(&dctx->d, sizeof(dctx->d));
OPENSSL_free(dctx);
}
return 0;
}
+static int fips_drbg_check(DRBG_CTX *dctx)
+ {
+ if (dctx->flags & DRBG_FLAG_TEST)
+ return 1;
+ dctx->health_check_cnt++;
+ if (dctx->health_check_cnt >= dctx->health_check_interval)
+ {
+ DRBG_CTX tctx;
+ if (!fips_drbg_kat(&tctx, dctx->type,
+ dctx->flags | DRBG_FLAG_TEST))
+ {
+ FIPSerr(FIPS_F_FIPS_DRBG_CHECK, FIPS_R_SELFTEST_FAILURE);
+ return 0;
+ }
+ dctx->health_check_cnt = 0;
+ }
+ return 1;
+ }
-static int fips_drbg_generate_internal(DRBG_CTX *dctx,
- unsigned char *out, size_t outlen,
+int FIPS_drbg_generate(DRBG_CTX *dctx, unsigned char *out, size_t outlen,
int strength, int prediction_resistance,
const unsigned char *adin, size_t adinlen)
{
int r = 0;
+ if (!fips_drbg_check(dctx))
+ return 0;
+
if (dctx->status != DRBG_STATUS_READY
&& dctx->status != DRBG_STATUS_RESEED)
{
if (r)
{
if (!(dctx->flags & DRBG_FLAG_NOERR))
- FIPSerr(FIPS_F_FIPS_DRBG_GENERATE_INTERNAL, r);
- return 0;
- }
-
- return 1;
- }
-
-/* external generate function: incorporates continuous RNG test if not
- * in test mode.
- */
-
-int FIPS_drbg_generate(DRBG_CTX *dctx,
- unsigned char *out, size_t outlen,
- int strength, int prediction_resistance,
- const unsigned char *adin, size_t adinlen)
- {
- unsigned char tmp[16], *pout;
- size_t poutlen;
- /* If test mode don't run continuous RNG test */
- if (dctx->flags & DRBG_FLAG_TEST)
- {
- return fips_drbg_generate_internal(dctx, out, outlen,
- strength,
- prediction_resistance,
- adin, adinlen);
- }
- /* If this is the first call generate block and save buffer */
- if (!dctx->lb_valid)
- {
- if (!fips_drbg_generate_internal(dctx, dctx->lb, 16,
- strength, prediction_resistance,
- adin, adinlen))
- return 0;
- dctx->lb_valid = 1;
- }
-
- /* If request less that 16 bytes request 16 in temp buffer */
-
- if (outlen < 16)
- {
- pout = tmp;
- poutlen = 16;
- }
- else
- {
- pout = out;
- poutlen = outlen;
- }
-
- /* Generate data */
- if (!fips_drbg_generate_internal(dctx, pout, poutlen,
- strength, prediction_resistance,
- adin, adinlen))
- return 0;
- /* Compare to last block for continuous PRNG test */
- if (!memcmp(pout, dctx->lb, 16))
- {
- FIPSerr(FIPS_F_FIPS_DRBG_GENERATE, FIPS_R_DRBG_STUCK);
+ FIPSerr(FIPS_F_FIPS_DRBG_GENERATE, r);
return 0;
}
- /* Update last block */
- memcpy(dctx->lb, pout, 16);
- /* Copy to output buffer if needed */
- if (outlen < 16)
- memcpy(out, pout, outlen);
return 1;
-
}
int FIPS_drbg_uninstantiate(DRBG_CTX *dctx)
/* Although we'd like to cleanse here we can't because we have to
* test the uninstantiate really zeroes the data.
*/
- memset(dctx, 0, sizeof(DRBG_CTX));
+ memset(&dctx->d, 0, sizeof(dctx->d));
+ dctx->status = DRBG_STATUS_UNINITIALISED;
/* If method has problems uninstantiating, return error */
return rv;
}
return 1;
}
+int FIPS_drbg_set_rand_callbacks(DRBG_CTX *dctx,
+ size_t (*get_adin)(DRBG_CTX *ctx, unsigned char **pout),
+ void (*cleanup_adin)(DRBG_CTX *ctx, unsigned char *out, size_t olen),
+ int (*rand_seed_cb)(DRBG_CTX *ctx, const void *buf, int num),
+ int (*rand_add_cb)(DRBG_CTX *ctx,
+ const void *buf, int num, double entropy))
+ {
+ if (dctx->status != DRBG_STATUS_UNINITIALISED)
+ return 0;
+ dctx->get_adin = get_adin;
+ dctx->cleanup_adin = cleanup_adin;
+ dctx->rand_seed_cb = rand_seed_cb;
+ dctx->rand_add_cb = rand_add_cb;
+ return 1;
+ }
+
void *FIPS_drbg_get_app_data(DRBG_CTX *dctx)
{
return dctx->app_data;
{
return dctx->strength;
}
+
+void FIPS_drbg_set_check_interval(DRBG_CTX *dctx, int interval)
+ {
+ dctx->health_check_interval = interval;
+ }
+
+static int drbg_stick = 0;
+
+void FIPS_drbg_stick(void)
+ {
+ drbg_stick = 1;
+ }
+
+/* Continuous DRBG utility function */
+int fips_drbg_cprng_test(DRBG_CTX *dctx, const unsigned char *out)
+ {
+ /* No CPRNG in test mode */
+ if (dctx->flags & DRBG_FLAG_TEST)
+ return 1;
+ /* Check block is valid: should never happen */
+ if (dctx->lb_valid == 0)
+ {
+ FIPSerr(FIPS_F_FIPS_DRBG_CPRNG_TEST, FIPS_R_INTERNAL_ERROR);
+ fips_set_selftest_fail();
+ return 0;
+ }
+ if (drbg_stick)
+ memcpy(dctx->lb, out, dctx->blocklength);
+ /* Check against last block: fail if match */
+ if (!memcmp(dctx->lb, out, dctx->blocklength))
+ {
+ FIPSerr(FIPS_F_FIPS_DRBG_CPRNG_TEST, FIPS_R_DRBG_STUCK);
+ fips_set_selftest_fail();
+ return 0;
+ }
+ /* Save last block for next comparison */
+ memcpy(dctx->lb, out, dctx->blocklength);
+ return 1;
+ }