Perform health check on all reseed operations not associated with

[openssl.git] / fips / rand / fips_drbg_lib.c

diff --git a/fips/rand/fips_drbg_lib.c b/fips/rand/fips_drbg_lib.c
index a0bb9eda64d53e949a8ff88f82543414108c1b91..9873742c4535967abebd6947ac80c589d0469a56 100644 (file)
--- a/fips/rand/fips_drbg_lib.c
+++ b/fips/rand/fips_drbg_lib.c
@@ -66,9 +66,10 @@ int FIPS_drbg_init(DRBG_CTX *dctx, int type, unsigned int flags)
        int rv;
        memset(dctx, 0, sizeof(DRBG_CTX));
        dctx->status = DRBG_STATUS_UNINITIALISED;
-       dctx->flags = flags;
+       dctx->xflags = flags;
        dctx->type = type;
 
+       dctx->iflags = 0;
        dctx->entropy_blocklen = 0;
        dctx->health_check_cnt = 0;
        dctx->health_check_interval = DRBG_HEALTH_INTERVAL;
@@ -79,6 +80,8 @@ int FIPS_drbg_init(DRBG_CTX *dctx, int type, unsigned int flags)
                rv = fips_drbg_ctr_init(dctx);
        if (rv == -2)
                rv = fips_drbg_hmac_init(dctx);
+       if (rv == -2)
+               rv = fips_drbg_ec_init(dctx);
 
        if (rv <= 0)
                {
@@ -90,7 +93,7 @@ int FIPS_drbg_init(DRBG_CTX *dctx, int type, unsigned int flags)
 
        /* If not in test mode run selftests on DRBG of the same type */
 
-       if (!(dctx->flags & DRBG_FLAG_TEST))
+       if (!(dctx->xflags & DRBG_FLAG_TEST))
                {
                DRBG_CTX tctx;
                if (!fips_drbg_kat(&tctx, type, flags | DRBG_FLAG_TEST))
@@ -113,8 +116,14 @@ DRBG_CTX *FIPS_drbg_new(int type, unsigned int flags)
                FIPSerr(FIPS_F_FIPS_DRBG_NEW, ERR_R_MALLOC_FAILURE);
                return NULL;
                }
+
        if (type == 0)
+               {
+               memset(dctx, 0, sizeof(DRBG_CTX));
+               dctx->type = 0;
+               dctx->status = DRBG_STATUS_UNINITIALISED;
                return dctx;
+               }
 
        if (FIPS_drbg_init(dctx, type, flags) <= 0)
                {
@@ -138,7 +147,7 @@ static size_t fips_get_entropy(DRBG_CTX *dctx, unsigned char **pout,
        {
        unsigned char *tout, *p;
        size_t bl = dctx->entropy_blocklen, rv;
-       if (dctx->flags & DRBG_FLAG_TEST || !bl)
+       if (dctx->xflags & DRBG_FLAG_TEST || !bl)
                return dctx->get_entropy(dctx, pout, entropy, min_len, max_len);
        rv = dctx->get_entropy(dctx, &tout, entropy + bl,
                                min_len + bl, max_len + bl);
@@ -164,7 +173,7 @@ static void fips_cleanup_entropy(DRBG_CTX *dctx,
                                        unsigned char *out, size_t olen)
        {
        size_t bl;
-       if (dctx->flags & DRBG_FLAG_TEST)
+       if (dctx->xflags & DRBG_FLAG_TEST)
                bl = 0;
        else
                bl = dctx->entropy_blocklen;
@@ -243,7 +252,8 @@ int FIPS_drbg_instantiate(DRBG_CTX *dctx,
 
 
        dctx->status = DRBG_STATUS_READY;
-       dctx->reseed_counter = 1;
+       if (!(dctx->iflags & DRBG_CUSTOM_RESEED))
+               dctx->reseed_counter = 1;
 
        end:
 
@@ -256,15 +266,15 @@ int FIPS_drbg_instantiate(DRBG_CTX *dctx,
        if (dctx->status == DRBG_STATUS_READY)
                return 1;
 
-       if (r && !(dctx->flags & DRBG_FLAG_NOERR))
+       if (r && !(dctx->iflags & DRBG_FLAG_NOERR))
                FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE, r);
 
        return 0;
 
        }
 
-int FIPS_drbg_reseed(DRBG_CTX *dctx,
-                       const unsigned char *adin, size_t adinlen)
+static int drbg_reseed(DRBG_CTX *dctx,
+                       const unsigned char *adin, size_t adinlen, int hcheck)
        {
        unsigned char *entropy = NULL;
        size_t entlen;
@@ -293,6 +303,17 @@ int FIPS_drbg_reseed(DRBG_CTX *dctx,
                }
 
        dctx->status = DRBG_STATUS_ERROR;
+       /* Peform health check on all reseed operations if not a prediction
+        * resistance request and not in test mode.
+        */
+       if (hcheck && !(dctx->xflags & DRBG_FLAG_TEST))
+               {
+               if (!FIPS_drbg_test(dctx))
+                       {
+                       r = FIPS_R_SELFTEST_FAILURE;
+                       goto end;
+                       }
+               }
 
        entlen = fips_get_entropy(dctx, &entropy, dctx->strength,
                                dctx->min_entropy, dctx->max_entropy);
@@ -307,7 +328,8 @@ int FIPS_drbg_reseed(DRBG_CTX *dctx,
                goto end;
 
        dctx->status = DRBG_STATUS_READY;
-       dctx->reseed_counter = 1;
+       if (!(dctx->iflags & DRBG_CUSTOM_RESEED))
+               dctx->reseed_counter = 1;
        end:
 
        if (entropy && dctx->cleanup_entropy)
@@ -316,22 +338,26 @@ int FIPS_drbg_reseed(DRBG_CTX *dctx,
        if (dctx->status == DRBG_STATUS_READY)
                return 1;
 
-       if (r && !(dctx->flags & DRBG_FLAG_NOERR))
+       if (r && !(dctx->iflags & DRBG_FLAG_NOERR))
                FIPSerr(FIPS_F_FIPS_DRBG_RESEED, r);
 
        return 0;
        }
 
+int FIPS_drbg_reseed(DRBG_CTX *dctx,
+                       const unsigned char *adin, size_t adinlen)
+       {
+       return drbg_reseed(dctx, adin, adinlen, 1);
+       }
+
 static int fips_drbg_check(DRBG_CTX *dctx)
        {
-       if (dctx->flags & DRBG_FLAG_TEST)
+       if (dctx->xflags & 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))
+               if (!FIPS_drbg_test(dctx))
                        {
                        FIPSerr(FIPS_F_FIPS_DRBG_CHECK, FIPS_R_SELFTEST_FAILURE);
                        dctx->status = DRBG_STATUS_ERROR;
@@ -343,7 +369,7 @@ static int fips_drbg_check(DRBG_CTX *dctx)
        }
 
 int FIPS_drbg_generate(DRBG_CTX *dctx, unsigned char *out, size_t outlen,
-                       int strength, int prediction_resistance,
+                       int prediction_resistance,
                        const unsigned char *adin, size_t adinlen)
        {
        int r = 0;
@@ -367,18 +393,23 @@ int FIPS_drbg_generate(DRBG_CTX *dctx, unsigned char *out, size_t outlen,
                return 0;
                }
 
-       if (strength > dctx->strength)
+       if (adinlen > dctx->max_adin)
                {
-               r = FIPS_R_INSUFFICIENT_SECURITY_STRENGTH;
+               r = FIPS_R_ADDITIONAL_INPUT_TOO_LONG;
                goto end;
                }
 
-       if (dctx->reseed_counter >= dctx->reseed_interval)
+       if (dctx->iflags & DRBG_CUSTOM_RESEED)
+               dctx->generate(dctx, NULL, outlen, NULL, 0);
+       else if (dctx->reseed_counter >= dctx->reseed_interval)
                dctx->status = DRBG_STATUS_RESEED;
 
        if (dctx->status == DRBG_STATUS_RESEED || prediction_resistance)
                {
-               if (!FIPS_drbg_reseed(dctx, adin, adinlen))
+               /* If prediction resistance request don't do health check */
+               int hcheck = prediction_resistance ? 0 : 1;
+               
+               if (!drbg_reseed(dctx, adin, adinlen, hcheck))
                        {
                        r = FIPS_R_RESEED_ERROR;
                        goto end;
@@ -393,15 +424,18 @@ int FIPS_drbg_generate(DRBG_CTX *dctx, unsigned char *out, size_t outlen,
                dctx->status = DRBG_STATUS_ERROR;
                goto end;
                }
-       if (dctx->reseed_counter >= dctx->reseed_interval)
-               dctx->status = DRBG_STATUS_RESEED;
-       else
-               dctx->reseed_counter++;
+       if (!(dctx->iflags & DRBG_CUSTOM_RESEED))
+               {
+               if (dctx->reseed_counter >= dctx->reseed_interval)
+                       dctx->status = DRBG_STATUS_RESEED;
+               else
+                       dctx->reseed_counter++;
+               }
 
        end:
        if (r)
                {
-               if (!(dctx->flags & DRBG_FLAG_NOERR))
+               if (!(dctx->iflags & DRBG_FLAG_NOERR))
                        FIPSerr(FIPS_F_FIPS_DRBG_GENERATE, r);
                return 0;
                }
@@ -485,6 +519,11 @@ void FIPS_drbg_set_check_interval(DRBG_CTX *dctx, int interval)
        dctx->health_check_interval = interval;
        }
 
+void FIPS_drbg_set_reseed_interval(DRBG_CTX *dctx, int interval)
+       {
+       dctx->reseed_interval = interval;
+       }
+
 static int drbg_stick = 0;
 
 void FIPS_drbg_stick(void)
@@ -496,7 +535,7 @@ void FIPS_drbg_stick(void)
 int fips_drbg_cprng_test(DRBG_CTX *dctx, const unsigned char *out)
        {
        /* No CPRNG in test mode */
-       if (dctx->flags & DRBG_FLAG_TEST)
+       if (dctx->xflags & DRBG_FLAG_TEST)
                return 1;
        /* Check block is valid: should never happen */
        if (dctx->lb_valid == 0)