|
Packit |
c4476c |
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
|
|
Packit |
c4476c |
* project.
|
|
Packit |
c4476c |
*/
|
|
Packit |
c4476c |
/* ====================================================================
|
|
Packit |
c4476c |
* Copyright (c) 2011 The OpenSSL Project. All rights reserved.
|
|
Packit |
c4476c |
*
|
|
Packit |
c4476c |
* Redistribution and use in source and binary forms, with or without
|
|
Packit |
c4476c |
* modification, are permitted provided that the following conditions
|
|
Packit |
c4476c |
* are met:
|
|
Packit |
c4476c |
*
|
|
Packit |
c4476c |
* 1. Redistributions of source code must retain the above copyright
|
|
Packit |
c4476c |
* notice, this list of conditions and the following disclaimer.
|
|
Packit |
c4476c |
*
|
|
Packit |
c4476c |
* 2. Redistributions in binary form must reproduce the above copyright
|
|
Packit |
c4476c |
* notice, this list of conditions and the following disclaimer in
|
|
Packit |
c4476c |
* the documentation and/or other materials provided with the
|
|
Packit |
c4476c |
* distribution.
|
|
Packit |
c4476c |
*
|
|
Packit |
c4476c |
* 3. All advertising materials mentioning features or use of this
|
|
Packit |
c4476c |
* software must display the following acknowledgment:
|
|
Packit |
c4476c |
* "This product includes software developed by the OpenSSL Project
|
|
Packit |
c4476c |
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|
Packit |
c4476c |
*
|
|
Packit |
c4476c |
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
|
Packit |
c4476c |
* endorse or promote products derived from this software without
|
|
Packit |
c4476c |
* prior written permission. For written permission, please contact
|
|
Packit |
c4476c |
* licensing@OpenSSL.org.
|
|
Packit |
c4476c |
*
|
|
Packit |
c4476c |
* 5. Products derived from this software may not be called "OpenSSL"
|
|
Packit |
c4476c |
* nor may "OpenSSL" appear in their names without prior written
|
|
Packit |
c4476c |
* permission of the OpenSSL Project.
|
|
Packit |
c4476c |
*
|
|
Packit |
c4476c |
* 6. Redistributions of any form whatsoever must retain the following
|
|
Packit |
c4476c |
* acknowledgment:
|
|
Packit |
c4476c |
* "This product includes software developed by the OpenSSL Project
|
|
Packit |
c4476c |
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|
Packit |
c4476c |
*
|
|
Packit |
c4476c |
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
|
Packit |
c4476c |
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
Packit |
c4476c |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
Packit |
c4476c |
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
|
Packit |
c4476c |
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
Packit |
c4476c |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
Packit |
c4476c |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
Packit |
c4476c |
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
Packit |
c4476c |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
Packit |
c4476c |
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
Packit |
c4476c |
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
Packit |
c4476c |
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
Packit |
c4476c |
* ====================================================================
|
|
Packit |
c4476c |
*/
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
#include <string.h>
|
|
Packit |
c4476c |
#include <openssl/crypto.h>
|
|
Packit |
c4476c |
#include <openssl/err.h>
|
|
Packit |
c4476c |
#include <openssl/fips.h>
|
|
Packit |
c4476c |
#include "crypto/fips.h"
|
|
Packit |
c4476c |
#include <openssl/fips_rand.h>
|
|
Packit |
c4476c |
#include "fips_locl.h"
|
|
Packit |
c4476c |
#include "fips_rand_lcl.h"
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
/* Support framework for SP800-90 DRBGs */
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_init(DRBG_CTX *dctx, int type, unsigned int flags)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
int rv;
|
|
Packit |
c4476c |
memset(dctx, 0, sizeof(DRBG_CTX));
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_UNINITIALISED;
|
|
Packit |
c4476c |
dctx->xflags = flags;
|
|
Packit |
c4476c |
dctx->type = type;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->iflags = 0;
|
|
Packit |
c4476c |
dctx->entropy_blocklen = 0;
|
|
Packit |
c4476c |
dctx->health_check_cnt = 0;
|
|
Packit |
c4476c |
dctx->health_check_interval = DRBG_HEALTH_INTERVAL;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
rv = fips_drbg_hash_init(dctx);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (rv == -2)
|
|
Packit |
c4476c |
rv = fips_drbg_ctr_init(dctx);
|
|
Packit |
c4476c |
if (rv == -2)
|
|
Packit |
c4476c |
rv = fips_drbg_hmac_init(dctx);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (rv <= 0) {
|
|
Packit |
c4476c |
if (rv == -2)
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INIT, FIPS_R_UNSUPPORTED_DRBG_TYPE);
|
|
Packit |
c4476c |
else
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INIT, FIPS_R_ERROR_INITIALISING_DRBG);
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
/* If not in test mode run selftests on DRBG of the same type */
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!(dctx->xflags & DRBG_FLAG_TEST)) {
|
|
Packit |
c4476c |
if (!FIPS_drbg_health_check(dctx)) {
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INIT, FIPS_R_SELFTEST_FAILURE);
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
return rv;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
DRBG_CTX *FIPS_drbg_new(int type, unsigned int flags)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
DRBG_CTX *dctx;
|
|
Packit |
c4476c |
dctx = OPENSSL_malloc(sizeof(DRBG_CTX));
|
|
Packit |
c4476c |
if (!dctx) {
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_NEW, ERR_R_MALLOC_FAILURE);
|
|
Packit |
c4476c |
return NULL;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (type == 0) {
|
|
Packit |
c4476c |
memset(dctx, 0, sizeof(DRBG_CTX));
|
|
Packit |
c4476c |
dctx->type = 0;
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_UNINITIALISED;
|
|
Packit |
c4476c |
return dctx;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (FIPS_drbg_init(dctx, type, flags) <= 0) {
|
|
Packit |
c4476c |
OPENSSL_free(dctx);
|
|
Packit |
c4476c |
return NULL;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
return dctx;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
void FIPS_drbg_free(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
if (dctx->uninstantiate)
|
|
Packit |
c4476c |
dctx->uninstantiate(dctx);
|
|
Packit |
c4476c |
/* Don't free up default DRBG */
|
|
Packit |
c4476c |
if (dctx == FIPS_get_default_drbg()) {
|
|
Packit |
c4476c |
memset(dctx, 0, sizeof(DRBG_CTX));
|
|
Packit |
c4476c |
dctx->type = 0;
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_UNINITIALISED;
|
|
Packit |
c4476c |
} else {
|
|
Packit |
c4476c |
OPENSSL_cleanse(&dctx->d, sizeof(dctx->d));
|
|
Packit |
c4476c |
OPENSSL_free(dctx);
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static size_t fips_get_entropy(DRBG_CTX *dctx, unsigned char **pout,
|
|
Packit |
c4476c |
int entropy, size_t min_len, size_t max_len)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
unsigned char *tout, *p;
|
|
Packit |
c4476c |
size_t bl = dctx->entropy_blocklen, rv;
|
|
Packit |
c4476c |
if (!dctx->get_entropy)
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (dctx->xflags & DRBG_FLAG_TEST || !bl)
|
|
Packit |
c4476c |
return dctx->get_entropy(dctx, pout, entropy, min_len, max_len);
|
|
Packit |
c4476c |
rv = dctx->get_entropy(dctx, &tout, entropy + bl,
|
|
Packit |
c4476c |
min_len + bl, max_len + bl);
|
|
Packit |
c4476c |
if (tout == NULL)
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
*pout = tout + bl;
|
|
Packit |
c4476c |
if (rv < (min_len + bl) || (rv % bl))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
/* Compare consecutive blocks for continuous PRNG test */
|
|
Packit |
c4476c |
for (p = tout; p < tout + rv - bl; p += bl) {
|
|
Packit |
c4476c |
if (!memcmp(p, p + bl, bl)) {
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_GET_ENTROPY, FIPS_R_ENTROPY_SOURCE_STUCK);
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
rv -= bl;
|
|
Packit |
c4476c |
if (rv > max_len)
|
|
Packit |
c4476c |
return max_len;
|
|
Packit |
c4476c |
return rv;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static void fips_cleanup_entropy(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
unsigned char *out, size_t olen)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
size_t bl;
|
|
Packit |
c4476c |
if (dctx->xflags & DRBG_FLAG_TEST)
|
|
Packit |
c4476c |
bl = 0;
|
|
Packit |
c4476c |
else
|
|
Packit |
c4476c |
bl = dctx->entropy_blocklen;
|
|
Packit |
c4476c |
/* Call cleanup with original arguments */
|
|
Packit |
c4476c |
dctx->cleanup_entropy(dctx, out - bl, olen + bl);
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_instantiate(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
const unsigned char *pers, size_t perslen)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
size_t entlen = 0, noncelen = 0;
|
|
Packit |
c4476c |
unsigned char *nonce = NULL, *entropy = NULL;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
#if 0
|
|
Packit |
c4476c |
/* Put here so error script picks them up */
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE,
|
|
Packit |
c4476c |
FIPS_R_PERSONALISATION_STRING_TOO_LONG);
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE, FIPS_R_IN_ERROR_STATE);
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE, FIPS_R_ALREADY_INSTANTIATED);
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE, FIPS_R_ERROR_RETRIEVING_ENTROPY);
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE, FIPS_R_ERROR_RETRIEVING_NONCE);
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE, FIPS_R_INSTANTIATE_ERROR);
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE, FIPS_R_DRBG_NOT_INITIALISED);
|
|
Packit |
c4476c |
#endif
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int r = 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (perslen > dctx->max_pers) {
|
|
Packit |
c4476c |
r = FIPS_R_PERSONALISATION_STRING_TOO_LONG;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!dctx->instantiate) {
|
|
Packit |
c4476c |
r = FIPS_R_DRBG_NOT_INITIALISED;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (dctx->status != DRBG_STATUS_UNINITIALISED) {
|
|
Packit |
c4476c |
if (dctx->status == DRBG_STATUS_ERROR)
|
|
Packit |
c4476c |
r = FIPS_R_IN_ERROR_STATE;
|
|
Packit |
c4476c |
else
|
|
Packit |
c4476c |
r = FIPS_R_ALREADY_INSTANTIATED;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_ERROR;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
entlen = fips_get_entropy(dctx, &entropy, dctx->strength,
|
|
Packit |
c4476c |
dctx->min_entropy, dctx->max_entropy);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (entlen < dctx->min_entropy || entlen > dctx->max_entropy) {
|
|
Packit |
c4476c |
r = FIPS_R_ERROR_RETRIEVING_ENTROPY;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (dctx->max_nonce > 0 && dctx->get_nonce) {
|
|
Packit |
c4476c |
noncelen = dctx->get_nonce(dctx, &nonce,
|
|
Packit |
c4476c |
dctx->strength / 2,
|
|
Packit |
c4476c |
dctx->min_nonce, dctx->max_nonce);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (noncelen < dctx->min_nonce || noncelen > dctx->max_nonce) {
|
|
Packit |
c4476c |
r = FIPS_R_ERROR_RETRIEVING_NONCE;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!dctx->instantiate(dctx,
|
|
Packit |
c4476c |
entropy, entlen, nonce, noncelen, pers, perslen)) {
|
|
Packit |
c4476c |
r = FIPS_R_ERROR_INSTANTIATING_DRBG;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_READY;
|
|
Packit |
c4476c |
if (!(dctx->iflags & DRBG_CUSTOM_RESEED))
|
|
Packit |
c4476c |
dctx->reseed_counter = 1;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
end:
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (entropy && dctx->cleanup_entropy)
|
|
Packit |
c4476c |
fips_cleanup_entropy(dctx, entropy, entlen);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (nonce && dctx->cleanup_nonce)
|
|
Packit |
c4476c |
dctx->cleanup_nonce(dctx, nonce, noncelen);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (dctx->status == DRBG_STATUS_READY)
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (r && !(dctx->iflags & DRBG_FLAG_NOERR))
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_INSTANTIATE, r);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int drbg_reseed(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
const unsigned char *adin, size_t adinlen, int hcheck)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
unsigned char *entropy = NULL;
|
|
Packit |
c4476c |
size_t entlen = 0;
|
|
Packit |
c4476c |
int r = 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
#if 0
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_DRBG_RESEED, FIPS_R_NOT_INSTANTIATED);
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_DRBG_RESEED, FIPS_R_ADDITIONAL_INPUT_TOO_LONG);
|
|
Packit |
c4476c |
#endif
|
|
Packit |
c4476c |
if (dctx->status != DRBG_STATUS_READY
|
|
Packit |
c4476c |
&& dctx->status != DRBG_STATUS_RESEED) {
|
|
Packit |
c4476c |
if (dctx->status == DRBG_STATUS_ERROR)
|
|
Packit |
c4476c |
r = FIPS_R_IN_ERROR_STATE;
|
|
Packit |
c4476c |
else if (dctx->status == DRBG_STATUS_UNINITIALISED)
|
|
Packit |
c4476c |
r = FIPS_R_NOT_INSTANTIATED;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!adin)
|
|
Packit |
c4476c |
adinlen = 0;
|
|
Packit |
c4476c |
else if (adinlen > dctx->max_adin) {
|
|
Packit |
c4476c |
r = FIPS_R_ADDITIONAL_INPUT_TOO_LONG;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_ERROR;
|
|
Packit |
c4476c |
/* Peform health check on all reseed operations if not a prediction
|
|
Packit |
c4476c |
* resistance request and not in test mode.
|
|
Packit |
c4476c |
*/
|
|
Packit |
c4476c |
if (hcheck && !(dctx->xflags & DRBG_FLAG_TEST)) {
|
|
Packit |
c4476c |
if (!FIPS_drbg_health_check(dctx)) {
|
|
Packit |
c4476c |
r = FIPS_R_SELFTEST_FAILURE;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
entlen = fips_get_entropy(dctx, &entropy, dctx->strength,
|
|
Packit |
c4476c |
dctx->min_entropy, dctx->max_entropy);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (entlen < dctx->min_entropy || entlen > dctx->max_entropy) {
|
|
Packit |
c4476c |
r = FIPS_R_ERROR_RETRIEVING_ENTROPY;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!dctx->reseed(dctx, entropy, entlen, adin, adinlen))
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_READY;
|
|
Packit |
c4476c |
if (!(dctx->iflags & DRBG_CUSTOM_RESEED))
|
|
Packit |
c4476c |
dctx->reseed_counter = 1;
|
|
Packit |
c4476c |
end:
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (entropy && dctx->cleanup_entropy)
|
|
Packit |
c4476c |
fips_cleanup_entropy(dctx, entropy, entlen);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (dctx->status == DRBG_STATUS_READY)
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (r && !(dctx->iflags & DRBG_FLAG_NOERR))
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_DRBG_RESEED, r);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_reseed(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
const unsigned char *adin, size_t adinlen)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
int len = (int)adinlen;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (len < 0 || (size_t)len != adinlen) {
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_DRBG_RESEED, FIPS_R_ADDITIONAL_INPUT_TOO_LONG);
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
RAND_seed(adin, len);
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_reseed_internal(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
const unsigned char *adin, size_t adinlen)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
return drbg_reseed(dctx, adin, adinlen, 1);
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int fips_drbg_check(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
if (dctx->xflags & DRBG_FLAG_TEST)
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
dctx->health_check_cnt++;
|
|
Packit |
c4476c |
if (dctx->health_check_cnt >= dctx->health_check_interval) {
|
|
Packit |
c4476c |
if (!FIPS_drbg_health_check(dctx)) {
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_CHECK, FIPS_R_SELFTEST_FAILURE);
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_generate(DRBG_CTX *dctx, unsigned char *out, size_t outlen,
|
|
Packit |
c4476c |
int prediction_resistance,
|
|
Packit |
c4476c |
const unsigned char *adin, size_t adinlen)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
int len = (int)outlen;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (len < 0 || (size_t)len != outlen) {
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_GENERATE, FIPS_R_REQUEST_TOO_LARGE_FOR_DRBG);
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
return RAND_bytes(out, len);
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_generate_internal(DRBG_CTX *dctx, unsigned char *out, size_t outlen,
|
|
Packit |
c4476c |
int prediction_resistance,
|
|
Packit |
c4476c |
const unsigned char *adin, size_t adinlen)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
int r = 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (FIPS_selftest_failed()) {
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_GENERATE, FIPS_R_SELFTEST_FAILED);
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!fips_drbg_check(dctx))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (dctx->status != DRBG_STATUS_READY
|
|
Packit |
c4476c |
&& dctx->status != DRBG_STATUS_RESEED) {
|
|
Packit |
c4476c |
if (dctx->status == DRBG_STATUS_ERROR)
|
|
Packit |
c4476c |
r = FIPS_R_IN_ERROR_STATE;
|
|
Packit |
c4476c |
else if (dctx->status == DRBG_STATUS_UNINITIALISED)
|
|
Packit |
c4476c |
r = FIPS_R_NOT_INSTANTIATED;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (outlen > dctx->max_request) {
|
|
Packit |
c4476c |
r = FIPS_R_REQUEST_TOO_LARGE_FOR_DRBG;
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (adinlen > dctx->max_adin) {
|
|
Packit |
c4476c |
r = FIPS_R_ADDITIONAL_INPUT_TOO_LONG;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (dctx->iflags & DRBG_CUSTOM_RESEED)
|
|
Packit |
c4476c |
dctx->generate(dctx, NULL, outlen, NULL, 0);
|
|
Packit |
c4476c |
else if (dctx->reseed_counter >= dctx->reseed_interval)
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_RESEED;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (dctx->status == DRBG_STATUS_RESEED || prediction_resistance) {
|
|
Packit |
c4476c |
/* If prediction resistance request don't do health check */
|
|
Packit |
c4476c |
int hcheck = prediction_resistance ? 0 : 1;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!drbg_reseed(dctx, adin, adinlen, hcheck)) {
|
|
Packit |
c4476c |
r = FIPS_R_RESEED_ERROR;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
adin = NULL;
|
|
Packit |
c4476c |
adinlen = 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!dctx->generate(dctx, out, outlen, adin, adinlen)) {
|
|
Packit |
c4476c |
r = FIPS_R_GENERATE_ERROR;
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_ERROR;
|
|
Packit |
c4476c |
goto end;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
if (!(dctx->iflags & DRBG_CUSTOM_RESEED)) {
|
|
Packit |
c4476c |
if (dctx->reseed_counter >= dctx->reseed_interval)
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_RESEED;
|
|
Packit |
c4476c |
else
|
|
Packit |
c4476c |
dctx->reseed_counter++;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
end:
|
|
Packit |
c4476c |
if (r) {
|
|
Packit |
c4476c |
if (!(dctx->iflags & DRBG_FLAG_NOERR))
|
|
Packit |
c4476c |
FIPSerr(FIPS_F_FIPS_DRBG_GENERATE, r);
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_uninstantiate(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
int rv;
|
|
Packit |
c4476c |
if (!dctx->uninstantiate)
|
|
Packit |
c4476c |
rv = 1;
|
|
Packit |
c4476c |
else
|
|
Packit |
c4476c |
rv = dctx->uninstantiate(dctx);
|
|
Packit |
c4476c |
/* Although we'd like to cleanse here we can't because we have to
|
|
Packit |
c4476c |
* test the uninstantiate really zeroes the data.
|
|
Packit |
c4476c |
*/
|
|
Packit |
c4476c |
memset(&dctx->d, 0, sizeof(dctx->d));
|
|
Packit |
c4476c |
dctx->status = DRBG_STATUS_UNINITIALISED;
|
|
Packit |
c4476c |
/* If method has problems uninstantiating, return error */
|
|
Packit |
c4476c |
return rv;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_set_callbacks(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
size_t (*get_entropy) (DRBG_CTX *ctx,
|
|
Packit |
c4476c |
unsigned char **pout,
|
|
Packit |
c4476c |
int entropy,
|
|
Packit |
c4476c |
size_t min_len,
|
|
Packit |
c4476c |
size_t max_len),
|
|
Packit |
c4476c |
void (*cleanup_entropy) (DRBG_CTX *ctx,
|
|
Packit |
c4476c |
unsigned char *out,
|
|
Packit |
c4476c |
size_t olen),
|
|
Packit |
c4476c |
size_t entropy_blocklen,
|
|
Packit |
c4476c |
size_t (*get_nonce) (DRBG_CTX *ctx,
|
|
Packit |
c4476c |
unsigned char **pout,
|
|
Packit |
c4476c |
int entropy, size_t min_len,
|
|
Packit |
c4476c |
size_t max_len),
|
|
Packit |
c4476c |
void (*cleanup_nonce) (DRBG_CTX *ctx,
|
|
Packit |
c4476c |
unsigned char *out,
|
|
Packit |
c4476c |
size_t olen))
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
if (dctx->status != DRBG_STATUS_UNINITIALISED)
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
dctx->entropy_blocklen = entropy_blocklen;
|
|
Packit |
c4476c |
dctx->get_entropy = get_entropy;
|
|
Packit |
c4476c |
dctx->cleanup_entropy = cleanup_entropy;
|
|
Packit |
c4476c |
dctx->get_nonce = get_nonce;
|
|
Packit |
c4476c |
dctx->cleanup_nonce = cleanup_nonce;
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_set_rand_callbacks(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
size_t (*get_adin) (DRBG_CTX *ctx,
|
|
Packit |
c4476c |
unsigned char **pout),
|
|
Packit |
c4476c |
void (*cleanup_adin) (DRBG_CTX *ctx,
|
|
Packit |
c4476c |
unsigned char *out,
|
|
Packit |
c4476c |
size_t olen),
|
|
Packit |
c4476c |
int (*rand_seed_cb) (DRBG_CTX *ctx,
|
|
Packit |
c4476c |
const void *buf,
|
|
Packit |
c4476c |
int num),
|
|
Packit |
c4476c |
int (*rand_add_cb) (DRBG_CTX *ctx,
|
|
Packit |
c4476c |
const void *buf, int num,
|
|
Packit |
c4476c |
double entropy))
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
if (dctx->status != DRBG_STATUS_UNINITIALISED)
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
dctx->get_adin = get_adin;
|
|
Packit |
c4476c |
dctx->cleanup_adin = cleanup_adin;
|
|
Packit |
c4476c |
dctx->rand_seed_cb = rand_seed_cb;
|
|
Packit |
c4476c |
dctx->rand_add_cb = rand_add_cb;
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
void *FIPS_drbg_get_app_data(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
return dctx->app_data;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
void FIPS_drbg_set_app_data(DRBG_CTX *dctx, void *app_data)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
dctx->app_data = app_data;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
size_t FIPS_drbg_get_blocklength(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
return dctx->blocklength;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int FIPS_drbg_get_strength(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
return dctx->strength;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
void FIPS_drbg_set_check_interval(DRBG_CTX *dctx, int interval)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
dctx->health_check_interval = interval;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
void FIPS_drbg_set_reseed_interval(DRBG_CTX *dctx, int interval)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
dctx->reseed_interval = interval;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
void FIPS_drbg_stick(int onoff)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
/* Just backwards compatibility API call with no effect. */
|
|
Packit |
c4476c |
}
|