/*-
* Copyright (c) 2019 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Taylor R. Campbell.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* cprng_strong
*
* Per-CPU NIST Hash_DRBG, reseeded automatically from the entropy
* pool when we transition to full entropy, never blocking. This
* is slightly different from the old cprng_strong API, but the
* only users of the old one fell into three categories:
*
* 1. never-blocking, oughta-be-per-CPU (kern_cprng, sysctl_prng)
* 2. never-blocking, used per-CPU anyway (/dev/urandom short reads)
* 3. /dev/random
*
* This code serves the first two categories without having extra
* logic for /dev/random.
*
* kern_cprng - available at IPL_SOFTSERIAL or lower
* user_cprng - available only at IPL_NONE in thread context
*
* The name kern_cprng is for hysterical raisins. The name
* user_cprng serves only to contrast with kern_cprng.
*/
/*
* struct cprng_cpu
*
* Per-CPU state for a cprng_strong. The DRBG and evcnt are
* allocated separately because percpu(9) sometimes moves per-CPU
* objects around without zeroing them.
*/
struct cprng_cpu {
struct nist_hash_drbg *cc_drbg;
struct {
struct evcnt reseed;
} *cc_evcnt;
unsigned cc_epoch;
};
if (__predict_false(nist_hash_drbg_initialize() != 0))
panic("NIST Hash_DRBG failed self-test");
/*
* Create CPRNG instances at two IPLs: IPL_SOFTSERIAL for
* kernel use that may occur inside soft interrupt handlers,
* and IPL_NONE for userland use which need not block
* interrupts.
*/
kern_cprng = cprng_strong_create("kern", IPL_SOFTSERIAL, 0);
user_cprng = cprng_strong_create("user", IPL_NONE, 0);
/*
* sysctl kern.urandom
*
* Independent uniform random 32-bit integer. Read-only.
*/
static int
sysctl_kern_urandom(SYSCTLFN_ARGS)
{
struct sysctlnode node = *rnode;
int v;
int error;
/* Generate an int's worth of data. */
cprng_strong(user_cprng, &v, sizeof v, 0);
/* Do the sysctl dance. */
node.sysctl_data = &v;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
/* Clear the buffer before returning the sysctl error. */
explicit_memset(&v, 0, sizeof v);
return error;
}
/*
* sysctl kern.arandom
*
* Independent uniform random bytes, up to 256 bytes. Read-only.
*/
static int
sysctl_kern_arandom(SYSCTLFN_ARGS)
{
struct sysctlnode node = *rnode;
uint8_t buf[256];
int error;
/*
* Clamp to a reasonably small size. 256 bytes is kind of
* arbitrary; 32 would be more reasonable, but we used 256 in
* the past, so let's not break compatibility.
*/
if (*oldlenp > 256) /* size_t, so never negative */
*oldlenp = 256;
/*
* Format the name as, e.g., kern/8 if we're on cpu8. This
* doesn't get displayed anywhere; it just ensures that if
* there were a bug causing us to use the same otherwise secure
* seed on multiple CPUs, we would still get independent output
* from the NIST Hash_DRBG.
*/
snprintf(namebuf, sizeof namebuf, "%s/%u", name, cpu_index(ci));
/*
* Allocate the struct nist_hash_drbg and struct evcnt
* separately, since percpu(9) may move objects around in
* memory without zeroing.
*/
cc->cc_drbg = kmem_zalloc(sizeof(*cc->cc_drbg), KM_SLEEP);
cc->cc_evcnt = kmem_alloc(sizeof(*cc->cc_evcnt), KM_SLEEP);
/*
* Initialize the DRBG with no seed. We do this in order to
* defer reading from the entropy pool as long as possible.
*/
if (__predict_false(nist_hash_drbg_instantiate(cc->cc_drbg,
zero, sizeof zero, NULL, 0, namebuf, strlen(namebuf))))
panic("nist_hash_drbg_instantiate");
/* Attach the event counters. */
/* XXX ci_cpuname may not be initialized early enough. */
cpuname = ci->ci_cpuname[0] == '\0' ? "cpu0" : ci->ci_cpuname;
evcnt_attach_dynamic(&cc->cc_evcnt->reseed, EVCNT_TYPE_MISC, NULL,
cpuname, "cprng_strong reseed");
/* Set the epoch uninitialized so we reseed on first use. */
cc->cc_epoch = 0;
}
/*
* Drop everything to extract a fresh seed from the entropy
* pool. entropy_extract may sleep on an adaptive lock, which
* invalidates our percpu(9) reference.
*
* This may race with reseeding in another thread, which is no
* big deal -- worst case, we rewind the entropy epoch here and
* cause the next caller to reseed again, and in the end we
* just reseed a couple more times than necessary.
*/
splx(*sp);
percpu_putref(cprng->cs_percpu);
entropy_extract(seed, sizeof seed, 0);
*ccp = percpu_getref(cprng->cs_percpu);
*sp = splraiseipl(cprng->cs_iplcookie);
size_t
cprng_strong(struct cprng_strong *cprng, void *buf, size_t len, int flags)
{
struct cprng_cpu *cc;
unsigned epoch;
int s;
/* Not allowed in hard interrupt context. */
KASSERT(!cpu_intr_p());
/*
* Verify maximum request length. Caller should really limit
* their requests to 32 bytes to avoid spending much time with
* preemption disabled -- use the 32 bytes to seed a private
* DRBG instance if you need more data.
*/
KASSERT(len <= CPRNG_MAX_LEN);
/* Verify legacy API use. */
KASSERT(flags == 0);
/* Acquire per-CPU state and block interrupts. */
cc = percpu_getref(cprng->cs_percpu);
s = splraiseipl(cprng->cs_iplcookie);
/* If the entropy epoch has changed, (re)seed. */
epoch = entropy_epoch();
if (__predict_false(epoch != cc->cc_epoch))
cprng_strong_reseed(cprng, epoch, &cc, &s);
/* Generate data. Failure here means it's time to reseed. */
if (__predict_false(nist_hash_drbg_generate(cc->cc_drbg, buf, len,
NULL, 0))) {
cprng_strong_reseed(cprng, epoch, &cc, &s);
if (__predict_false(nist_hash_drbg_generate(cc->cc_drbg,
buf, len, NULL, 0)))
panic("nist_hash_drbg_generate");
}
/* Release state and interrupts. */
splx(s);
percpu_putref(cprng->cs_percpu);
/* Return the number of bytes generated, for hysterical raisins. */
return len;
}
