|
Packit |
c4476c |
/* fips/rand/fips_drbg_hash.c */
|
|
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 |
#define OPENSSL_FIPSAPI
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
#include <stdlib.h>
|
|
Packit |
c4476c |
#include <string.h>
|
|
Packit |
c4476c |
#include <openssl/crypto.h>
|
|
Packit |
c4476c |
#include <openssl/fips.h>
|
|
Packit |
c4476c |
#include "crypto/fips.h"
|
|
Packit |
c4476c |
#include <openssl/fips_rand.h>
|
|
Packit |
c4476c |
#include "fips_rand_lcl.h"
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
/* This is Hash_df from SP 800-90 10.4.1 */
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int hash_df(DRBG_CTX *dctx, unsigned char *out,
|
|
Packit |
c4476c |
const unsigned char *in1, size_t in1len,
|
|
Packit |
c4476c |
const unsigned char *in2, size_t in2len,
|
|
Packit |
c4476c |
const unsigned char *in3, size_t in3len,
|
|
Packit |
c4476c |
const unsigned char *in4, size_t in4len)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
EVP_MD_CTX *mctx = dctx->d.hash.mctx;
|
|
Packit |
c4476c |
unsigned char *vtmp = dctx->d.hash.vtmp;
|
|
Packit |
c4476c |
unsigned char tmp[6];
|
|
Packit |
c4476c |
/* Standard only ever needs seedlen bytes which is always less than
|
|
Packit |
c4476c |
* maximum permitted so no need to check length.
|
|
Packit |
c4476c |
*/
|
|
Packit |
c4476c |
size_t outlen = dctx->seedlen;
|
|
Packit |
c4476c |
tmp[0] = 1;
|
|
Packit |
c4476c |
tmp[1] = ((outlen * 8) >> 24) & 0xff;
|
|
Packit |
c4476c |
tmp[2] = ((outlen * 8) >> 16) & 0xff;
|
|
Packit |
c4476c |
tmp[3] = ((outlen * 8) >> 8) & 0xff;
|
|
Packit |
c4476c |
tmp[4] = (outlen * 8) & 0xff;
|
|
Packit |
c4476c |
if (!in1) {
|
|
Packit |
c4476c |
tmp[5] = (unsigned char)in1len;
|
|
Packit |
c4476c |
in1 = tmp + 5;
|
|
Packit |
c4476c |
in1len = 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
for (;;) {
|
|
Packit |
c4476c |
if (!FIPS_digestinit(mctx, dctx->d.hash.md))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (!FIPS_digestupdate(mctx, tmp, 5))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (in1 && !FIPS_digestupdate(mctx, in1, in1len))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (in2 && !FIPS_digestupdate(mctx, in2, in2len))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (in3 && !FIPS_digestupdate(mctx, in3, in3len))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (in4 && !FIPS_digestupdate(mctx, in4, in4len))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (outlen < dctx->blocklength) {
|
|
Packit |
c4476c |
if (!FIPS_digestfinal(mctx, vtmp, NULL))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
memcpy(out, vtmp, outlen);
|
|
Packit |
c4476c |
OPENSSL_cleanse(vtmp, dctx->blocklength);
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
} else if (!FIPS_digestfinal(mctx, out, NULL))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
outlen -= dctx->blocklength;
|
|
Packit |
c4476c |
if (outlen == 0)
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
tmp[0]++;
|
|
Packit |
c4476c |
out += dctx->blocklength;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
/* Add an unsigned buffer to the buf value, storing the result in buf. For
|
|
Packit |
c4476c |
* this algorithm the length of input never exceeds the seed length.
|
|
Packit |
c4476c |
*/
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static void ctx_add_buf(DRBG_CTX *dctx, unsigned char *buf,
|
|
Packit |
c4476c |
unsigned char *in, size_t inlen)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
size_t i = inlen;
|
|
Packit |
c4476c |
const unsigned char *q;
|
|
Packit |
c4476c |
unsigned char c, *p;
|
|
Packit |
c4476c |
p = buf + dctx->seedlen;
|
|
Packit |
c4476c |
q = in + inlen;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
OPENSSL_assert(i <= dctx->seedlen);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
/* Special case: zero length, just increment buffer */
|
|
Packit |
c4476c |
if (i)
|
|
Packit |
c4476c |
c = 0;
|
|
Packit |
c4476c |
else
|
|
Packit |
c4476c |
c = 1;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
while (i) {
|
|
Packit |
c4476c |
int r;
|
|
Packit |
c4476c |
p--;
|
|
Packit |
c4476c |
q--;
|
|
Packit |
c4476c |
r = *p + *q + c;
|
|
Packit |
c4476c |
/* Carry */
|
|
Packit |
c4476c |
if (r > 0xff)
|
|
Packit |
c4476c |
c = 1;
|
|
Packit |
c4476c |
else
|
|
Packit |
c4476c |
c = 0;
|
|
Packit |
c4476c |
*p = r & 0xff;
|
|
Packit |
c4476c |
i--;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
i = dctx->seedlen - inlen;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
/* If not adding whole buffer handle final carries */
|
|
Packit |
c4476c |
if (c && i) {
|
|
Packit |
c4476c |
do {
|
|
Packit |
c4476c |
p--;
|
|
Packit |
c4476c |
c = *p;
|
|
Packit |
c4476c |
c++;
|
|
Packit |
c4476c |
*p = c;
|
|
Packit |
c4476c |
if (c)
|
|
Packit |
c4476c |
return;
|
|
Packit |
c4476c |
} while (i--);
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
/* Finalise and add hash to V */
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int ctx_add_md(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
if (!FIPS_digestfinal(dctx->d.hash.mctx, dctx->d.hash.vtmp, NULL))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
ctx_add_buf(dctx, dctx->d.hash.V, dctx->d.hash.vtmp, dctx->blocklength);
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int hash_gen(DRBG_CTX *dctx, unsigned char *out, size_t outlen)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
DRBG_HASH_CTX *hctx = &dctx->d.hash;
|
|
Packit |
c4476c |
if (outlen == 0)
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
memcpy(hctx->vtmp, hctx->V, dctx->seedlen);
|
|
Packit |
c4476c |
for (;;) {
|
|
Packit |
c4476c |
FIPS_digestinit(hctx->mctx, hctx->md);
|
|
Packit |
c4476c |
FIPS_digestupdate(hctx->mctx, hctx->vtmp, dctx->seedlen);
|
|
Packit |
c4476c |
if (outlen < dctx->blocklength) {
|
|
Packit |
c4476c |
FIPS_digestfinal(hctx->mctx, hctx->vtmp, NULL);
|
|
Packit |
c4476c |
memcpy(out, hctx->vtmp, outlen);
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
} else {
|
|
Packit |
c4476c |
FIPS_digestfinal(hctx->mctx, out, NULL);
|
|
Packit |
c4476c |
outlen -= dctx->blocklength;
|
|
Packit |
c4476c |
if (outlen == 0)
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
out += dctx->blocklength;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
ctx_add_buf(dctx, hctx->vtmp, NULL, 0);
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int drbg_hash_instantiate(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
const unsigned char *ent, size_t ent_len,
|
|
Packit |
c4476c |
const unsigned char *nonce, size_t nonce_len,
|
|
Packit |
c4476c |
const unsigned char *pstr, size_t pstr_len)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
DRBG_HASH_CTX *hctx = &dctx->d.hash;
|
|
Packit |
c4476c |
if (!hash_df(dctx, hctx->V,
|
|
Packit |
c4476c |
ent, ent_len, nonce, nonce_len, pstr, pstr_len, NULL, 0))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (!hash_df(dctx, hctx->C,
|
|
Packit |
c4476c |
NULL, 0, hctx->V, dctx->seedlen, NULL, 0, NULL, 0))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
#ifdef HASH_DRBG_TRACE
|
|
Packit |
c4476c |
fprintf(stderr, "V+C after instantiate:\n");
|
|
Packit |
c4476c |
hexprint(stderr, hctx->V, dctx->seedlen);
|
|
Packit |
c4476c |
hexprint(stderr, hctx->C, dctx->seedlen);
|
|
Packit |
c4476c |
#endif
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int drbg_hash_reseed(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
const unsigned char *ent, size_t ent_len,
|
|
Packit |
c4476c |
const unsigned char *adin, size_t adin_len)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
DRBG_HASH_CTX *hctx = &dctx->d.hash;
|
|
Packit |
c4476c |
/* V about to be updated so use C as output instead */
|
|
Packit |
c4476c |
if (!hash_df(dctx, hctx->C,
|
|
Packit |
c4476c |
NULL, 1, hctx->V, dctx->seedlen,
|
|
Packit |
c4476c |
ent, ent_len, adin, adin_len))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
memcpy(hctx->V, hctx->C, dctx->seedlen);
|
|
Packit |
c4476c |
if (!hash_df(dctx, hctx->C, NULL, 0,
|
|
Packit |
c4476c |
hctx->V, dctx->seedlen, NULL, 0, NULL, 0))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
#ifdef HASH_DRBG_TRACE
|
|
Packit |
c4476c |
fprintf(stderr, "V+C after reseed:\n");
|
|
Packit |
c4476c |
hexprint(stderr, hctx->V, dctx->seedlen);
|
|
Packit |
c4476c |
hexprint(stderr, hctx->C, dctx->seedlen);
|
|
Packit |
c4476c |
#endif
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int drbg_hash_generate(DRBG_CTX *dctx,
|
|
Packit |
c4476c |
unsigned char *out, size_t outlen,
|
|
Packit |
c4476c |
const unsigned char *adin, size_t adin_len)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
DRBG_HASH_CTX *hctx = &dctx->d.hash;
|
|
Packit |
c4476c |
EVP_MD_CTX *mctx = hctx->mctx;
|
|
Packit |
c4476c |
unsigned char tmp[4];
|
|
Packit |
c4476c |
if (adin && adin_len) {
|
|
Packit |
c4476c |
tmp[0] = 2;
|
|
Packit |
c4476c |
if (!FIPS_digestinit(mctx, hctx->md))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (!EVP_DigestUpdate(mctx, tmp, 1))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (!EVP_DigestUpdate(mctx, hctx->V, dctx->seedlen))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (!EVP_DigestUpdate(mctx, adin, adin_len))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (!ctx_add_md(dctx))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
if (!hash_gen(dctx, out, outlen))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
tmp[0] = 3;
|
|
Packit |
c4476c |
if (!FIPS_digestinit(mctx, hctx->md))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (!EVP_DigestUpdate(mctx, tmp, 1))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
if (!EVP_DigestUpdate(mctx, hctx->V, dctx->seedlen))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
if (!ctx_add_md(dctx))
|
|
Packit |
c4476c |
return 0;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
ctx_add_buf(dctx, hctx->V, hctx->C, dctx->seedlen);
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
tmp[0] = (dctx->reseed_counter >> 24) & 0xff;
|
|
Packit |
c4476c |
tmp[1] = (dctx->reseed_counter >> 16) & 0xff;
|
|
Packit |
c4476c |
tmp[2] = (dctx->reseed_counter >> 8) & 0xff;
|
|
Packit |
c4476c |
tmp[3] = dctx->reseed_counter & 0xff;
|
|
Packit |
c4476c |
ctx_add_buf(dctx, hctx->V, tmp, 4);
|
|
Packit |
c4476c |
#ifdef HASH_DRBG_TRACE
|
|
Packit |
c4476c |
fprintf(stderr, "V+C after generate:\n");
|
|
Packit |
c4476c |
hexprint(stderr, hctx->V, dctx->seedlen);
|
|
Packit |
c4476c |
hexprint(stderr, hctx->C, dctx->seedlen);
|
|
Packit |
c4476c |
#endif
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
static int drbg_hash_uninstantiate(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
EVP_MD_CTX_free(dctx->d.hash.mctx);
|
|
Packit |
c4476c |
OPENSSL_cleanse(&dctx->d.hash, sizeof(DRBG_HASH_CTX));
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
int fips_drbg_hash_init(DRBG_CTX *dctx)
|
|
Packit |
c4476c |
{
|
|
Packit |
c4476c |
const EVP_MD *md;
|
|
Packit |
c4476c |
DRBG_HASH_CTX *hctx = &dctx->d.hash;
|
|
Packit |
c4476c |
md = EVP_get_digestbynid(dctx->type);
|
|
Packit |
c4476c |
if (!md)
|
|
Packit |
c4476c |
return -2;
|
|
Packit |
c4476c |
switch (dctx->type) {
|
|
Packit |
c4476c |
case NID_sha1:
|
|
Packit |
c4476c |
dctx->strength = 128;
|
|
Packit |
c4476c |
break;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
case NID_sha224:
|
|
Packit |
c4476c |
dctx->strength = 192;
|
|
Packit |
c4476c |
break;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
default:
|
|
Packit |
c4476c |
dctx->strength = 256;
|
|
Packit |
c4476c |
break;
|
|
Packit |
c4476c |
}
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->instantiate = drbg_hash_instantiate;
|
|
Packit |
c4476c |
dctx->reseed = drbg_hash_reseed;
|
|
Packit |
c4476c |
dctx->generate = drbg_hash_generate;
|
|
Packit |
c4476c |
dctx->uninstantiate = drbg_hash_uninstantiate;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->d.hash.md = md;
|
|
Packit |
c4476c |
hctx->mctx = EVP_MD_CTX_new();
|
|
Packit |
c4476c |
if (hctx->mctx == NULL)
|
|
Packit |
c4476c |
return -1;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
/* These are taken from SP 800-90 10.1 table 2 */
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->blocklength = EVP_MD_size(md);
|
|
Packit |
c4476c |
if (dctx->blocklength > 32)
|
|
Packit |
c4476c |
dctx->seedlen = 111;
|
|
Packit |
c4476c |
else
|
|
Packit |
c4476c |
dctx->seedlen = 55;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->min_entropy = dctx->strength / 8;
|
|
Packit |
c4476c |
dctx->max_entropy = DRBG_MAX_LENGTH;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->min_nonce = dctx->min_entropy / 2;
|
|
Packit |
c4476c |
dctx->max_nonce = DRBG_MAX_LENGTH;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->max_pers = DRBG_MAX_LENGTH;
|
|
Packit |
c4476c |
dctx->max_adin = DRBG_MAX_LENGTH;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
dctx->max_request = 1 << 16;
|
|
Packit |
c4476c |
dctx->reseed_interval = 1 << 24;
|
|
Packit |
c4476c |
|
|
Packit |
c4476c |
return 1;
|
|
Packit |
c4476c |
}
|