diff mbox series

[ovs-dev,v3,3/4] random: Provide OpenSSL EVP cipher as a CSPRNG source.

Message ID 20261028191456.500378-4-aconole@ovn.org
State New
Headers show
Series userspace: Add a CSPRNG for NAT hash basis and tuple selection | expand

Checks

Context Check Description
ovsrobot/apply-robot success apply and check: success
ovsrobot/github-robot-_Build_and_Test success github build: passed
ovsrobot/github-robot-_FreeBSD_Build_and_Test fail github build: failed

Commit Message

Aaron Conole Oct. 28, 2026, 7:14 p.m. UTC
This commit makes the ChaCha20 CSPRNG prefer using
OpenSSL's SIMD optimized ChaCha20 on platforms which
are compiled with such support.  This represents a
major improvement on performance, without impacting
the underlying CSPRNG functionality.

The EVP backend re-keys from the first bytes of every
refill, just as the built-in implementation does, so
that the fast key erasure - and thus the forward
secrecy - of the generator is the same for both.  The
built-in ChaCha20 implementation is always built so
that it can serve as a fallback when OpenSSL is unable
to provide ChaCha20, for example when it only offers
approved algorithms in FIPS mode.

Assisted-by: LLM (claude, opencode, sonnet, opus, qwen3.8)
Signed-off-by: Aaron Conole <aconole@ovn.org>
---
v2->v3:
  * Update the the csprng to provide local ChaCha20 when
    openssl isn't available for many reasons.
  * Updated the cs_random_bytes() max comment (since the OpenSSL
    version will shrink the max a bit more).
  * Updated the rekey to provide forward key erasure and forward
    secrecy.

 lib/random.c | 217 ++++++++++++++++++++++++++++++++++++++++++---------
 lib/random.h |   2 +-
 2 files changed, 182 insertions(+), 37 deletions(-)

Comments

Ilya Maximets Oct. 29, 2026, 2:52 p.m. UTC | #1
On 10/28/26 8:14 PM, Aaron Conole wrote:
> This commit makes the ChaCha20 CSPRNG prefer using
> OpenSSL's SIMD optimized ChaCha20 on platforms which
> are compiled with such support.  This represents a
> major improvement on performance, without impacting
> the underlying CSPRNG functionality.
> 
> The EVP backend re-keys from the first bytes of every
> refill, just as the built-in implementation does, so
> that the fast key erasure - and thus the forward
> secrecy - of the generator is the same for both.  The
> built-in ChaCha20 implementation is always built so
> that it can serve as a fallback when OpenSSL is unable
> to provide ChaCha20, for example when it only offers
> approved algorithms in FIPS mode.
> 
> Assisted-by: LLM (claude, opencode, sonnet, opus, qwen3.8)

I guess, we should consider dropping this tag as kernel did. :)

> Signed-off-by: Aaron Conole <aconole@ovn.org>
> ---
> v2->v3:
>   * Update the the csprng to provide local ChaCha20 when
>     openssl isn't available for many reasons.
>   * Updated the cs_random_bytes() max comment (since the OpenSSL
>     version will shrink the max a bit more).
>   * Updated the rekey to provide forward key erasure and forward
>     secrecy.
> 
>  lib/random.c | 217 ++++++++++++++++++++++++++++++++++++++++++---------
>  lib/random.h |   2 +-
>  2 files changed, 182 insertions(+), 37 deletions(-)
> 
> diff --git a/lib/random.c b/lib/random.c
> index d2f28866a2..27d57530f7 100644
> --- a/lib/random.c
> +++ b/lib/random.c
> @@ -18,15 +18,24 @@
>  #include "random.h"
>  
>  #include <errno.h>
> +#include <stdbool.h>
>  #include <stdlib.h>
>  #include <sys/time.h>
>  
> +#if defined(HAVE_OPENSSL) && !defined(OPENSSL_NO_CHACHA)

OPENSSL_NO_CHACHA is probably never defined here as we didn't include
any OpenSSL headers yet.  Or am I missing something?

> +#include <openssl/evp.h>
> +#define HAVE_CHACHA20_EVP 1

Can we detect that at configuration time?  The EVP_chacha20() function
should not be defined with OPENSSL_NO_CHACHA.

> +#endif
> +
>  #include "byte-order.h"
>  #include "entropy.h"
>  #include "hash.h"
>  #include "ovs-thread.h"
>  #include "timeval.h"
>  #include "util.h"
> +#include "openvswitch/vlog.h"

Can we order this lexicographically?

> +
> +VLOG_DEFINE_THIS_MODULE(random);
>  
>  /* This is the 32-bit PRNG recommended in G. Marsaglia, "Xorshift RNGs",
>   * _Journal of Statistical Software_ 8:14 (July 2003).  According to the paper,
> @@ -120,6 +129,39 @@ random_next(void)
>  }
>  
>  
> +/* Cryptographic secure pseudo-random number generator. */
> +
> +/* Refill a page worth of keystream at a time to amortize the block cost. */
> +#define CSPRNG_BUFSZ    4096
> +
> +#define CHACHA_KEYLEN   32          /* 256-bit key. */
> +#define CHACHA_IVLEN    16          /* ChaCha20 IV: counter and nonce. */
> +
> +/* Reseed from the OS entropy pool after this many bytes served, matching
> + * the arc4random policy of periodic reseeding. */
> +#define CSPRNG_RESEED   (1600 * 1024)
> +
> +#ifdef HAVE_CHACHA20_EVP
> +/* The OpenSSL EVP backend consumes an IV in addition to a key. */
> +#define CSPRNG_SECRETS  (CHACHA_KEYLEN + CHACHA_IVLEN)
> +#else
> +#define CSPRNG_SECRETS  CHACHA_KEYLEN
> +#endif
> +
> +struct csprng {
> +#ifdef HAVE_CHACHA20_EVP
> +    EVP_CIPHER_CTX *ctx;            /* OpenSSL EVP state, once created. */
> +    bool use_evp;                   /* Serve from OpenSSL rather than the
> +                                     * built-in implementation. */
> +#endif
> +    uint32_t state[16];             /* ChaCha20 state:
> +                                     * constant|key|counter|nonce. */
> +    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
> +    size_t pos;                     /* Next unused byte in 'buf'. */
> +    size_t served;                  /* Bytes served since last reseed. */
> +    int initialized;
> +};
> +
>  /* This is a 32-bit CSPRNG adapted from the ChaCha20 algorithm described in
>   * RFC 7539 and RFC 8439, similar to arc4random(3) and the Linux kernel's
>   * get_random_u32().
> @@ -130,14 +172,6 @@ random_next(void)
>   */
>  
>  #define CHACHA_ROUNDS   20
> -#define CHACHA_KEYLEN   32          /* 256-bit key. */
> -
> -/* Refill a page worth of keystream at a time to amortize the block cost. */
> -#define CSPRNG_BUFSZ    4096
> -
> -/* Reseed from the OS entropy pool after this many bytes served, matching
> - * the arc4random policy of periodic reseeding. */
> -#define CSPRNG_RESEED   (1600 * 1024)
>  
>  #define ROTL32(v, n)    (((v) << (n)) | ((v) >> (32 - (n))))
>  
> @@ -147,20 +181,13 @@ random_next(void)
>      a += b; d ^= a; d = ROTL32(d, 8);           \
>      c += d; b ^= c; b = ROTL32(b, 7)
>  
> -struct csprng {
> -    uint32_t state[16];             /* ChaCha20 state:
> -                                     * constant|key|counter|nonce. */
> -    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
> -    size_t pos;                     /* Next unused byte in 'buf'. */
> -    size_t served;                  /* Bytes served since last reseed. */
> -    int initialized;
> -};
> -
>  /* ChaCha20 constant: "expand 32-byte k".  Must be at least 16 bytes + NUL. */
>  static const uint8_t chacha_sigma[] = "expand 32-byte k";
>  
> +#ifndef HAVE_CHACHA20_EVP
>  /* Current random state. */
>  DEFINE_STATIC_PER_THREAD_DATA(struct csprng, cs_state, { .initialized = 0 });
> +#endif
>  
>  /* Produces one 64-byte ChaCha20 block from 'input' (16 words) into 'out'. */
>  void
> @@ -211,22 +238,8 @@ csprng_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
>      }
>  }
>  
> -static void
> -csprng_seed(struct csprng *c)
> -{
> -    uint8_t key[CHACHA_KEYLEN];
> -
> -    get_entropy_or_die(key, sizeof key);
> -    csprng_rekey(c, key);
> -    ovs_memzero(key, sizeof key);
> -
> -    c->pos = sizeof c->buf;
> -    c->served = 0;
> -    c->initialized = 1;
> -}
> -
> -/* Fills csprng with fresh keystream, reserving the first 32 bytes to re-key
> - * the generator (fast key erasure / forward secrecy). */
> +/* Fills 'c' with fresh keystream, reserving the first 32 bytes to re-key the
> + * generator (fast key erasure / forward secrecy). */
>  static void
>  csprng_refill(struct csprng *c)
>  {
> @@ -246,21 +259,153 @@ csprng_refill(struct csprng *c)
>      c->pos = CHACHA_KEYLEN;
>  }
>  
> +#ifdef HAVE_CHACHA20_EVP
> +/* This is the EVP based CSPRNG using the OpenSSL EVP framework to create a
> + * long stream of bytes, and pull those.  The OpenSSL EVP manages the
> + * underlying bytes, all this does is manage the policy.  It re-keys from the
> + * beginning of every refill, as the built-in implementation above does, so
> + * that both provide the same fast key erasure.
> + */
> +
> +static void
> +csprng_state_destroy(void *ctx)
> +{
> +    struct csprng *csp = ctx;
> +
> +    if (csp->ctx) {
> +        EVP_CIPHER_CTX_free(csp->ctx);
> +        csp->ctx = NULL;
> +    }
> +
> +    free(csp);
> +}
> +
> +static struct csprng *
> +cs_state_get(void)
> +{
> +    static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
> +    static ovsthread_key_t cskey;
> +    struct csprng *csp;
> +
> +    if (ovsthread_once_start(&once)) {
> +        ovsthread_key_create(&cskey, csprng_state_destroy);
> +        ovsthread_once_done(&once);
> +    }
> +
> +    csp = ovsthread_getspecific(cskey);
> +    if (!csp) {
> +        csp = xzalloc(sizeof *csp);
> +        csp->use_evp = true;
> +        ovsthread_setspecific(cskey, csp);
> +    }
> +    return csp;
> +}
> +
> +/* (Re)keys the OpenSSL EVP state from 'key' (32 bytes) and 'iv' (16 bytes). */
> +static bool
> +csprng_evp_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN],
> +                 const uint8_t iv[CHACHA_IVLEN])
> +{
> +    return EVP_EncryptInit_ex(c->ctx, EVP_chacha20(), NULL, key, iv) == 1;
> +}
> +
> +/* Seeds the OpenSSL EVP state from fresh entropy, returning false if OpenSSL
> + * cannot provide ChaCha20. */
> +static bool
> +csprng_evp_seed(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
> +{
> +    uint8_t iv[CHACHA_IVLEN];
> +    bool ok;
> +
> +    if (!c->ctx) {
> +        c->ctx = EVP_CIPHER_CTX_new();
> +        if (!c->ctx) {
> +            VLOG_WARN_ONCE("cs_random: cannot create cipher context.");
> +            return false;
> +        }
> +    }
> +
> +    get_entropy_or_die(iv, sizeof iv);
> +    ok = csprng_evp_rekey(c, key, iv);
> +    ovs_memzero(iv, sizeof iv);
> +
> +    if (!ok) {
> +        /* OpenSSL may not provide ChaCha20 at all, for example when it only
> +         * offers approved algorithms in FIPS mode.  Fall back to the built-in
> +         * implementation rather than failing to provide randomness. */
> +        VLOG_WARN_ONCE("cs_random: OpenSSL ChaCha20 unavailable, using the "
> +                       "built-in implementation.");
> +    }
> +    return ok;
> +}
> +
> +/* Fills 'c' with fresh keystream from OpenSSL, reserving the first bytes to
> + * re-key the generator (fast key erasure / forward secrecy). */
> +static void
> +csprng_evp_refill(struct csprng *c)
> +{
> +    static const uint8_t zero[CSPRNG_BUFSZ];
> +    int outl;
> +
> +    if (EVP_EncryptUpdate(c->ctx, c->buf, &outl, zero, sizeof c->buf) != 1 ||
> +        outl != sizeof c->buf) {
> +        VLOG_FATAL("cs_random: EVP fill failure.");
> +    }
> +
> +    csprng_evp_rekey(c, c->buf, c->buf + CHACHA_KEYLEN);

What happens if this function returns 'false' ?

Best regards, Ilya Maximets.
Aaron Conole Oct. 30, 2026, 12:04 p.m. UTC | #2
Ilya Maximets <i.maximets@ovn.org> writes:

> On 10/28/26 8:14 PM, Aaron Conole wrote:
>> This commit makes the ChaCha20 CSPRNG prefer using
>> OpenSSL's SIMD optimized ChaCha20 on platforms which
>> are compiled with such support.  This represents a
>> major improvement on performance, without impacting
>> the underlying CSPRNG functionality.
>> 
>> The EVP backend re-keys from the first bytes of every
>> refill, just as the built-in implementation does, so
>> that the fast key erasure - and thus the forward
>> secrecy - of the generator is the same for both.  The
>> built-in ChaCha20 implementation is always built so
>> that it can serve as a fallback when OpenSSL is unable
>> to provide ChaCha20, for example when it only offers
>> approved algorithms in FIPS mode.
>> 
>> Assisted-by: LLM (claude, opencode, sonnet, opus, qwen3.8)
>
> I guess, we should consider dropping this tag as kernel did. :)

+1  :)

>> Signed-off-by: Aaron Conole <aconole@ovn.org>
>> ---
>> v2->v3:
>>   * Update the the csprng to provide local ChaCha20 when
>>     openssl isn't available for many reasons.
>>   * Updated the cs_random_bytes() max comment (since the OpenSSL
>>     version will shrink the max a bit more).
>>   * Updated the rekey to provide forward key erasure and forward
>>     secrecy.
>> 
>>  lib/random.c | 217 ++++++++++++++++++++++++++++++++++++++++++---------
>>  lib/random.h |   2 +-
>>  2 files changed, 182 insertions(+), 37 deletions(-)
>> 
>> diff --git a/lib/random.c b/lib/random.c
>> index d2f28866a2..27d57530f7 100644
>> --- a/lib/random.c
>> +++ b/lib/random.c
>> @@ -18,15 +18,24 @@
>>  #include "random.h"
>>  
>>  #include <errno.h>
>> +#include <stdbool.h>
>>  #include <stdlib.h>
>>  #include <sys/time.h>
>>  
>> +#if defined(HAVE_OPENSSL) && !defined(OPENSSL_NO_CHACHA)
>
> OPENSSL_NO_CHACHA is probably never defined here as we didn't include
> any OpenSSL headers yet.  Or am I missing something?

I'll double check, and fix on next version if needed.

>> +#include <openssl/evp.h>
>> +#define HAVE_CHACHA20_EVP 1
>
> Can we detect that at configuration time?  The EVP_chacha20() function
> should not be defined with OPENSSL_NO_CHACHA.

Probably a better approach.

>> +#endif
>> +
>>  #include "byte-order.h"
>>  #include "entropy.h"
>>  #include "hash.h"
>>  #include "ovs-thread.h"
>>  #include "timeval.h"
>>  #include "util.h"
>> +#include "openvswitch/vlog.h"
>
> Can we order this lexicographically?

ACK

>> +
>> +VLOG_DEFINE_THIS_MODULE(random);
>>  
>>  /* This is the 32-bit PRNG recommended in G. Marsaglia, "Xorshift RNGs",
>>   * _Journal of Statistical Software_ 8:14 (July 2003).  According to the paper,
>> @@ -120,6 +129,39 @@ random_next(void)
>>  }
>>  
>>  
>> +/* Cryptographic secure pseudo-random number generator. */
>> +
>> +/* Refill a page worth of keystream at a time to amortize the block cost. */
>> +#define CSPRNG_BUFSZ    4096
>> +
>> +#define CHACHA_KEYLEN   32          /* 256-bit key. */
>> +#define CHACHA_IVLEN    16          /* ChaCha20 IV: counter and nonce. */
>> +
>> +/* Reseed from the OS entropy pool after this many bytes served, matching
>> + * the arc4random policy of periodic reseeding. */
>> +#define CSPRNG_RESEED   (1600 * 1024)
>> +
>> +#ifdef HAVE_CHACHA20_EVP
>> +/* The OpenSSL EVP backend consumes an IV in addition to a key. */
>> +#define CSPRNG_SECRETS  (CHACHA_KEYLEN + CHACHA_IVLEN)
>> +#else
>> +#define CSPRNG_SECRETS  CHACHA_KEYLEN
>> +#endif
>> +
>> +struct csprng {
>> +#ifdef HAVE_CHACHA20_EVP
>> +    EVP_CIPHER_CTX *ctx;            /* OpenSSL EVP state, once created. */
>> +    bool use_evp;                   /* Serve from OpenSSL rather than the
>> +                                     * built-in implementation. */
>> +#endif
>> +    uint32_t state[16];             /* ChaCha20 state:
>> +                                     * constant|key|counter|nonce. */
>> +    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
>> +    size_t pos;                     /* Next unused byte in 'buf'. */
>> +    size_t served;                  /* Bytes served since last reseed. */
>> +    int initialized;
>> +};
>> +
>>  /* This is a 32-bit CSPRNG adapted from the ChaCha20 algorithm described in
>>   * RFC 7539 and RFC 8439, similar to arc4random(3) and the Linux kernel's
>>   * get_random_u32().
>> @@ -130,14 +172,6 @@ random_next(void)
>>   */
>>  
>>  #define CHACHA_ROUNDS   20
>> -#define CHACHA_KEYLEN   32          /* 256-bit key. */
>> -
>> -/* Refill a page worth of keystream at a time to amortize the block cost. */
>> -#define CSPRNG_BUFSZ    4096
>> -
>> -/* Reseed from the OS entropy pool after this many bytes served, matching
>> - * the arc4random policy of periodic reseeding. */
>> -#define CSPRNG_RESEED   (1600 * 1024)
>>  
>>  #define ROTL32(v, n)    (((v) << (n)) | ((v) >> (32 - (n))))
>>  
>> @@ -147,20 +181,13 @@ random_next(void)
>>      a += b; d ^= a; d = ROTL32(d, 8);           \
>>      c += d; b ^= c; b = ROTL32(b, 7)
>>  
>> -struct csprng {
>> -    uint32_t state[16];             /* ChaCha20 state:
>> -                                     * constant|key|counter|nonce. */
>> -    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
>> -    size_t pos;                     /* Next unused byte in 'buf'. */
>> -    size_t served;                  /* Bytes served since last reseed. */
>> -    int initialized;
>> -};
>> -
>>  /* ChaCha20 constant: "expand 32-byte k".  Must be at least 16 bytes + NUL. */
>>  static const uint8_t chacha_sigma[] = "expand 32-byte k";
>>  
>> +#ifndef HAVE_CHACHA20_EVP
>>  /* Current random state. */
>>  DEFINE_STATIC_PER_THREAD_DATA(struct csprng, cs_state, { .initialized = 0 });
>> +#endif
>>  
>>  /* Produces one 64-byte ChaCha20 block from 'input' (16 words) into 'out'. */
>>  void
>> @@ -211,22 +238,8 @@ csprng_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
>>      }
>>  }
>>  
>> -static void
>> -csprng_seed(struct csprng *c)
>> -{
>> -    uint8_t key[CHACHA_KEYLEN];
>> -
>> -    get_entropy_or_die(key, sizeof key);
>> -    csprng_rekey(c, key);
>> -    ovs_memzero(key, sizeof key);
>> -
>> -    c->pos = sizeof c->buf;
>> -    c->served = 0;
>> -    c->initialized = 1;
>> -}
>> -
>> -/* Fills csprng with fresh keystream, reserving the first 32 bytes to re-key
>> - * the generator (fast key erasure / forward secrecy). */
>> +/* Fills 'c' with fresh keystream, reserving the first 32 bytes to re-key the
>> + * generator (fast key erasure / forward secrecy). */
>>  static void
>>  csprng_refill(struct csprng *c)
>>  {
>> @@ -246,21 +259,153 @@ csprng_refill(struct csprng *c)
>>      c->pos = CHACHA_KEYLEN;
>>  }
>>  
>> +#ifdef HAVE_CHACHA20_EVP
>> +/* This is the EVP based CSPRNG using the OpenSSL EVP framework to create a
>> + * long stream of bytes, and pull those.  The OpenSSL EVP manages the
>> + * underlying bytes, all this does is manage the policy.  It re-keys from the
>> + * beginning of every refill, as the built-in implementation above does, so
>> + * that both provide the same fast key erasure.
>> + */
>> +
>> +static void
>> +csprng_state_destroy(void *ctx)
>> +{
>> +    struct csprng *csp = ctx;
>> +
>> +    if (csp->ctx) {
>> +        EVP_CIPHER_CTX_free(csp->ctx);
>> +        csp->ctx = NULL;
>> +    }
>> +
>> +    free(csp);
>> +}
>> +
>> +static struct csprng *
>> +cs_state_get(void)
>> +{
>> +    static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
>> +    static ovsthread_key_t cskey;
>> +    struct csprng *csp;
>> +
>> +    if (ovsthread_once_start(&once)) {
>> +        ovsthread_key_create(&cskey, csprng_state_destroy);
>> +        ovsthread_once_done(&once);
>> +    }
>> +
>> +    csp = ovsthread_getspecific(cskey);
>> +    if (!csp) {
>> +        csp = xzalloc(sizeof *csp);
>> +        csp->use_evp = true;
>> +        ovsthread_setspecific(cskey, csp);
>> +    }
>> +    return csp;
>> +}
>> +
>> +/* (Re)keys the OpenSSL EVP state from 'key' (32 bytes) and 'iv' (16 bytes). */
>> +static bool
>> +csprng_evp_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN],
>> +                 const uint8_t iv[CHACHA_IVLEN])
>> +{
>> +    return EVP_EncryptInit_ex(c->ctx, EVP_chacha20(), NULL, key, iv) == 1;
>> +}
>> +
>> +/* Seeds the OpenSSL EVP state from fresh entropy, returning false if OpenSSL
>> + * cannot provide ChaCha20. */
>> +static bool
>> +csprng_evp_seed(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
>> +{
>> +    uint8_t iv[CHACHA_IVLEN];
>> +    bool ok;
>> +
>> +    if (!c->ctx) {
>> +        c->ctx = EVP_CIPHER_CTX_new();
>> +        if (!c->ctx) {
>> +            VLOG_WARN_ONCE("cs_random: cannot create cipher context.");
>> +            return false;
>> +        }
>> +    }
>> +
>> +    get_entropy_or_die(iv, sizeof iv);
>> +    ok = csprng_evp_rekey(c, key, iv);
>> +    ovs_memzero(iv, sizeof iv);
>> +
>> +    if (!ok) {
>> +        /* OpenSSL may not provide ChaCha20 at all, for example when it only
>> +         * offers approved algorithms in FIPS mode.  Fall back to the built-in
>> +         * implementation rather than failing to provide randomness. */
>> +        VLOG_WARN_ONCE("cs_random: OpenSSL ChaCha20 unavailable, using the "
>> +                       "built-in implementation.");
>> +    }
>> +    return ok;
>> +}
>> +
>> +/* Fills 'c' with fresh keystream from OpenSSL, reserving the first bytes to
>> + * re-key the generator (fast key erasure / forward secrecy). */
>> +static void
>> +csprng_evp_refill(struct csprng *c)
>> +{
>> +    static const uint8_t zero[CSPRNG_BUFSZ];
>> +    int outl;
>> +
>> +    if (EVP_EncryptUpdate(c->ctx, c->buf, &outl, zero, sizeof c->buf) != 1 ||
>> +        outl != sizeof c->buf) {
>> +        VLOG_FATAL("cs_random: EVP fill failure.");
>> +    }
>> +
>> +    csprng_evp_rekey(c, c->buf, c->buf + CHACHA_KEYLEN);
>
> What happens if this function returns 'false' ?

What?! It won't :)

I guess it can, so I'll handle that case in next version.

> Best regards, Ilya Maximets.
Rosemarie O'Riorden Oct. 30, 2026, 6:51 p.m. UTC | #3
Hi Aaron, this isn't a full review at all but I noticed two little nits
while going over this series.

On 10/28/26 3:14 PM, Aaron Conole via dev wrote:
> This commit makes the ChaCha20 CSPRNG prefer using
> OpenSSL's SIMD optimized ChaCha20 on platforms which
> are compiled with such support.  This represents a
> major improvement on performance, without impacting
> the underlying CSPRNG functionality.
> 
> The EVP backend re-keys from the first bytes of every
> refill, just as the built-in implementation does, so
> that the fast key erasure - and thus the forward
> secrecy - of the generator is the same for both.  The
> built-in ChaCha20 implementation is always built so
> that it can serve as a fallback when OpenSSL is unable
> to provide ChaCha20, for example when it only offers
> approved algorithms in FIPS mode.
> 
> Assisted-by: LLM (claude, opencode, sonnet, opus, qwen3.8)
> Signed-off-by: Aaron Conole <aconole@ovn.org>
> ---
> v2->v3:
>   * Update the the csprng to provide local ChaCha20 when
>     openssl isn't available for many reasons.
>   * Updated the cs_random_bytes() max comment (since the OpenSSL
>     version will shrink the max a bit more).
>   * Updated the rekey to provide forward key erasure and forward
>     secrecy.
> 
>  lib/random.c | 217 ++++++++++++++++++++++++++++++++++++++++++---------
>  lib/random.h |   2 +-
>  2 files changed, 182 insertions(+), 37 deletions(-)
> 
> diff --git a/lib/random.c b/lib/random.c
> index d2f28866a2..27d57530f7 100644
> --- a/lib/random.c
> +++ b/lib/random.c
> @@ -18,15 +18,24 @@
>  #include "random.h"
>  
>  #include <errno.h>
> +#include <stdbool.h>
>  #include <stdlib.h>
>  #include <sys/time.h>
>  
> +#if defined(HAVE_OPENSSL) && !defined(OPENSSL_NO_CHACHA)
> +#include <openssl/evp.h>
> +#define HAVE_CHACHA20_EVP 1
> +#endif
> +
>  #include "byte-order.h"
>  #include "entropy.h"
>  #include "hash.h"
>  #include "ovs-thread.h"
>  #include "timeval.h"
>  #include "util.h"
> +#include "openvswitch/vlog.h"
> +
> +VLOG_DEFINE_THIS_MODULE(random);
>  
>  /* This is the 32-bit PRNG recommended in G. Marsaglia, "Xorshift RNGs",
>   * _Journal of Statistical Software_ 8:14 (July 2003).  According to the paper,
> @@ -120,6 +129,39 @@ random_next(void)
>  }
>  
>  
> +/* Cryptographic secure pseudo-random number generator. */
> +
> +/* Refill a page worth of keystream at a time to amortize the block cost. */
> +#define CSPRNG_BUFSZ    4096
> +
> +#define CHACHA_KEYLEN   32          /* 256-bit key. */
> +#define CHACHA_IVLEN    16          /* ChaCha20 IV: counter and nonce. */
> +
> +/* Reseed from the OS entropy pool after this many bytes served, matching
> + * the arc4random policy of periodic reseeding. */
> +#define CSPRNG_RESEED   (1600 * 1024)
> +
> +#ifdef HAVE_CHACHA20_EVP
> +/* The OpenSSL EVP backend consumes an IV in addition to a key. */
> +#define CSPRNG_SECRETS  (CHACHA_KEYLEN + CHACHA_IVLEN)
> +#else
> +#define CSPRNG_SECRETS  CHACHA_KEYLEN
> +#endif
> +
> +struct csprng {
> +#ifdef HAVE_CHACHA20_EVP
> +    EVP_CIPHER_CTX *ctx;            /* OpenSSL EVP state, once created. */
> +    bool use_evp;                   /* Serve from OpenSSL rather than the
> +                                     * built-in implementation. */
> +#endif
> +    uint32_t state[16];             /* ChaCha20 state:
> +                                     * constant|key|counter|nonce. */
> +    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
> +    size_t pos;                     /* Next unused byte in 'buf'. */
> +    size_t served;                  /* Bytes served since last reseed. */
> +    int initialized;
> +};
> +
>  /* This is a 32-bit CSPRNG adapted from the ChaCha20 algorithm described in
>   * RFC 7539 and RFC 8439, similar to arc4random(3) and the Linux kernel's
>   * get_random_u32().
> @@ -130,14 +172,6 @@ random_next(void)
>   */
>  
>  #define CHACHA_ROUNDS   20
> -#define CHACHA_KEYLEN   32          /* 256-bit key. */
> -
> -/* Refill a page worth of keystream at a time to amortize the block cost. */
> -#define CSPRNG_BUFSZ    4096
> -
> -/* Reseed from the OS entropy pool after this many bytes served, matching
> - * the arc4random policy of periodic reseeding. */
> -#define CSPRNG_RESEED   (1600 * 1024)
>  
>  #define ROTL32(v, n)    (((v) << (n)) | ((v) >> (32 - (n))))
>  
> @@ -147,20 +181,13 @@ random_next(void)
>      a += b; d ^= a; d = ROTL32(d, 8);           \
>      c += d; b ^= c; b = ROTL32(b, 7)
>  
> -struct csprng {
> -    uint32_t state[16];             /* ChaCha20 state:
> -                                     * constant|key|counter|nonce. */
> -    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
> -    size_t pos;                     /* Next unused byte in 'buf'. */
> -    size_t served;                  /* Bytes served since last reseed. */
> -    int initialized;
> -};
> -
>  /* ChaCha20 constant: "expand 32-byte k".  Must be at least 16 bytes + NUL. */
>  static const uint8_t chacha_sigma[] = "expand 32-byte k";
>  
> +#ifndef HAVE_CHACHA20_EVP
>  /* Current random state. */
>  DEFINE_STATIC_PER_THREAD_DATA(struct csprng, cs_state, { .initialized = 0 });
> +#endif
>  
>  /* Produces one 64-byte ChaCha20 block from 'input' (16 words) into 'out'. */
>  void
> @@ -211,22 +238,8 @@ csprng_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
>      }
>  }
>  
> -static void
> -csprng_seed(struct csprng *c)
> -{
> -    uint8_t key[CHACHA_KEYLEN];
> -
> -    get_entropy_or_die(key, sizeof key);
> -    csprng_rekey(c, key);
> -    ovs_memzero(key, sizeof key);
> -
> -    c->pos = sizeof c->buf;
> -    c->served = 0;
> -    c->initialized = 1;
> -}
> -
> -/* Fills csprng with fresh keystream, reserving the first 32 bytes to re-key
> - * the generator (fast key erasure / forward secrecy). */
> +/* Fills 'c' with fresh keystream, reserving the first 32 bytes to re-key the
> + * generator (fast key erasure / forward secrecy). */

Nit: This can be rebased into patch 2 of the set.

>  static void
>  csprng_refill(struct csprng *c)
>  {
> @@ -246,21 +259,153 @@ csprng_refill(struct csprng *c)
>      c->pos = CHACHA_KEYLEN;
>  }
>  
> +#ifdef HAVE_CHACHA20_EVP
> +/* This is the EVP based CSPRNG using the OpenSSL EVP framework to create a
> + * long stream of bytes, and pull those.  The OpenSSL EVP manages the
> + * underlying bytes, all this does is manage the policy.  It re-keys from the
> + * beginning of every refill, as the built-in implementation above does, so
> + * that both provide the same fast key erasure.
> + */
> +
> +static void
> +csprng_state_destroy(void *ctx)
> +{
> +    struct csprng *csp = ctx;
> +
> +    if (csp->ctx) {
> +        EVP_CIPHER_CTX_free(csp->ctx);
> +        csp->ctx = NULL;
> +    }
> +
> +    free(csp);
> +}

Nit: It would be nice if the above and below functions followed the same
naming convention.

- Rosemarie O'Riorden

> +
> +static struct csprng *
> +cs_state_get(void)
> +{
> +    static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
> +    static ovsthread_key_t cskey;
> +    struct csprng *csp;
> +
> +    if (ovsthread_once_start(&once)) {
> +        ovsthread_key_create(&cskey, csprng_state_destroy);
> +        ovsthread_once_done(&once);
> +    }
> +
> +    csp = ovsthread_getspecific(cskey);
> +    if (!csp) {
> +        csp = xzalloc(sizeof *csp);
> +        csp->use_evp = true;
> +        ovsthread_setspecific(cskey, csp);
> +    }
> +    return csp;
> +}
> +
> +/* (Re)keys the OpenSSL EVP state from 'key' (32 bytes) and 'iv' (16 bytes). */
> +static bool
> +csprng_evp_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN],
> +                 const uint8_t iv[CHACHA_IVLEN])
> +{
> +    return EVP_EncryptInit_ex(c->ctx, EVP_chacha20(), NULL, key, iv) == 1;
> +}
> +
> +/* Seeds the OpenSSL EVP state from fresh entropy, returning false if OpenSSL
> + * cannot provide ChaCha20. */
> +static bool
> +csprng_evp_seed(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
> +{
> +    uint8_t iv[CHACHA_IVLEN];
> +    bool ok;
> +
> +    if (!c->ctx) {
> +        c->ctx = EVP_CIPHER_CTX_new();
> +        if (!c->ctx) {
> +            VLOG_WARN_ONCE("cs_random: cannot create cipher context.");
> +            return false;
> +        }
> +    }
> +
> +    get_entropy_or_die(iv, sizeof iv);
> +    ok = csprng_evp_rekey(c, key, iv);
> +    ovs_memzero(iv, sizeof iv);
> +
> +    if (!ok) {
> +        /* OpenSSL may not provide ChaCha20 at all, for example when it only
> +         * offers approved algorithms in FIPS mode.  Fall back to the built-in
> +         * implementation rather than failing to provide randomness. */
> +        VLOG_WARN_ONCE("cs_random: OpenSSL ChaCha20 unavailable, using the "
> +                       "built-in implementation.");
> +    }
> +    return ok;
> +}
> +
> +/* Fills 'c' with fresh keystream from OpenSSL, reserving the first bytes to
> + * re-key the generator (fast key erasure / forward secrecy). */
> +static void
> +csprng_evp_refill(struct csprng *c)
> +{
> +    static const uint8_t zero[CSPRNG_BUFSZ];
> +    int outl;
> +
> +    if (EVP_EncryptUpdate(c->ctx, c->buf, &outl, zero, sizeof c->buf) != 1 ||
> +        outl != sizeof c->buf) {
> +        VLOG_FATAL("cs_random: EVP fill failure.");
> +    }
> +
> +    csprng_evp_rekey(c, c->buf, c->buf + CHACHA_KEYLEN);
> +    ovs_memzero(c->buf, CSPRNG_SECRETS);
> +    c->pos = CSPRNG_SECRETS;
> +}
> +#endif /* HAVE_CHACHA20_EVP */
> +
> +static void
> +csprng_seed(struct csprng *c)
> +{
> +    uint8_t key[CHACHA_KEYLEN];
> +
> +    get_entropy_or_die(key, sizeof key);
> +
> +#ifdef HAVE_CHACHA20_EVP
> +    if (c->use_evp && !csprng_evp_seed(c, key)) {
> +        c->use_evp = false;
> +    }
> +    if (!c->use_evp) {
> +        csprng_rekey(c, key);
> +    }
> +#else
> +    csprng_rekey(c, key);
> +#endif
> +
> +    ovs_memzero(key, sizeof key);
> +
> +    c->pos = sizeof c->buf;
> +    c->served = 0;
> +    c->initialized = 1;
> +}
> +
>  void
>  cs_random_bytes(void *b, size_t l)
>  {
>      struct csprng *c = cs_state_get();
>  
> -    /* c->buf isn't fully available for reading because the first 32 bytes
> -     * of every refill are consumed as the next key. */
> -    ovs_assert(l <= sizeof c->buf - CHACHA_KEYLEN);
> +    /* c->buf isn't fully available for reading because the first bytes of
> +     * every refill are consumed as the next key and IV. */
> +    ovs_assert(l <= sizeof c->buf - CSPRNG_SECRETS);
>  
>      if (!c->initialized || c->served >= CSPRNG_RESEED) {
>          csprng_seed(c);
>      }
>  
>      if (c->pos + l > sizeof c->buf) {
> +#ifdef HAVE_CHACHA20_EVP
> +        if (c->use_evp) {
> +            csprng_evp_refill(c);
> +        } else {
> +            csprng_refill(c);
> +        }
> +#else
>          csprng_refill(c);
> +#endif
>      }
>  
>      memcpy(b, c->buf + c->pos, l);
> diff --git a/lib/random.h b/lib/random.h
> index 77792e28f1..76f165c7a8 100644
> --- a/lib/random.h
> +++ b/lib/random.h
> @@ -53,7 +53,7 @@ void chacha20_block(const uint32_t input[CHACHA_K_INPUT],
>                      uint8_t out[CHACHA_BLOCK]);
>  
>  /* Fills 'b' with 'l' cryptographically secure random bytes.  'l' must not be
> - * larger than 4064; callers needing more bytes should make multiple calls. */
> + * larger than 4048; callers needing more bytes should make multiple calls. */
>  void cs_random_bytes(void *, size_t);
>  uint32_t cs_random_uint32(void);
>
Aaron Conole Oct. 31, 2026, 3:32 p.m. UTC | #4
Rosemarie O'Riorden <rosemarie@redhat.com> writes:

> Hi Aaron, this isn't a full review at all but I noticed two little nits
> while going over this series.
>
> On 10/28/26 3:14 PM, Aaron Conole via dev wrote:
>> This commit makes the ChaCha20 CSPRNG prefer using
>> OpenSSL's SIMD optimized ChaCha20 on platforms which
>> are compiled with such support.  This represents a
>> major improvement on performance, without impacting
>> the underlying CSPRNG functionality.
>> 
>> The EVP backend re-keys from the first bytes of every
>> refill, just as the built-in implementation does, so
>> that the fast key erasure - and thus the forward
>> secrecy - of the generator is the same for both.  The
>> built-in ChaCha20 implementation is always built so
>> that it can serve as a fallback when OpenSSL is unable
>> to provide ChaCha20, for example when it only offers
>> approved algorithms in FIPS mode.
>> 
>> Assisted-by: LLM (claude, opencode, sonnet, opus, qwen3.8)
>> Signed-off-by: Aaron Conole <aconole@ovn.org>
>> ---
>> v2->v3:
>>   * Update the the csprng to provide local ChaCha20 when
>>     openssl isn't available for many reasons.
>>   * Updated the cs_random_bytes() max comment (since the OpenSSL
>>     version will shrink the max a bit more).
>>   * Updated the rekey to provide forward key erasure and forward
>>     secrecy.
>> 
>>  lib/random.c | 217 ++++++++++++++++++++++++++++++++++++++++++---------
>>  lib/random.h |   2 +-
>>  2 files changed, 182 insertions(+), 37 deletions(-)
>> 
>> diff --git a/lib/random.c b/lib/random.c
>> index d2f28866a2..27d57530f7 100644
>> --- a/lib/random.c
>> +++ b/lib/random.c
>> @@ -18,15 +18,24 @@
>>  #include "random.h"
>>  
>>  #include <errno.h>
>> +#include <stdbool.h>
>>  #include <stdlib.h>
>>  #include <sys/time.h>
>>  
>> +#if defined(HAVE_OPENSSL) && !defined(OPENSSL_NO_CHACHA)
>> +#include <openssl/evp.h>
>> +#define HAVE_CHACHA20_EVP 1
>> +#endif
>> +
>>  #include "byte-order.h"
>>  #include "entropy.h"
>>  #include "hash.h"
>>  #include "ovs-thread.h"
>>  #include "timeval.h"
>>  #include "util.h"
>> +#include "openvswitch/vlog.h"
>> +
>> +VLOG_DEFINE_THIS_MODULE(random);
>>  
>>  /* This is the 32-bit PRNG recommended in G. Marsaglia, "Xorshift RNGs",
>>   * _Journal of Statistical Software_ 8:14 (July 2003).  According to the paper,
>> @@ -120,6 +129,39 @@ random_next(void)
>>  }
>>  
>>  
>> +/* Cryptographic secure pseudo-random number generator. */
>> +
>> +/* Refill a page worth of keystream at a time to amortize the block cost. */
>> +#define CSPRNG_BUFSZ    4096
>> +
>> +#define CHACHA_KEYLEN   32          /* 256-bit key. */
>> +#define CHACHA_IVLEN    16          /* ChaCha20 IV: counter and nonce. */
>> +
>> +/* Reseed from the OS entropy pool after this many bytes served, matching
>> + * the arc4random policy of periodic reseeding. */
>> +#define CSPRNG_RESEED   (1600 * 1024)
>> +
>> +#ifdef HAVE_CHACHA20_EVP
>> +/* The OpenSSL EVP backend consumes an IV in addition to a key. */
>> +#define CSPRNG_SECRETS  (CHACHA_KEYLEN + CHACHA_IVLEN)
>> +#else
>> +#define CSPRNG_SECRETS  CHACHA_KEYLEN
>> +#endif
>> +
>> +struct csprng {
>> +#ifdef HAVE_CHACHA20_EVP
>> +    EVP_CIPHER_CTX *ctx;            /* OpenSSL EVP state, once created. */
>> +    bool use_evp;                   /* Serve from OpenSSL rather than the
>> +                                     * built-in implementation. */
>> +#endif
>> +    uint32_t state[16];             /* ChaCha20 state:
>> +                                     * constant|key|counter|nonce. */
>> +    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
>> +    size_t pos;                     /* Next unused byte in 'buf'. */
>> +    size_t served;                  /* Bytes served since last reseed. */
>> +    int initialized;
>> +};
>> +
>>  /* This is a 32-bit CSPRNG adapted from the ChaCha20 algorithm described in
>>   * RFC 7539 and RFC 8439, similar to arc4random(3) and the Linux kernel's
>>   * get_random_u32().
>> @@ -130,14 +172,6 @@ random_next(void)
>>   */
>>  
>>  #define CHACHA_ROUNDS   20
>> -#define CHACHA_KEYLEN   32          /* 256-bit key. */
>> -
>> -/* Refill a page worth of keystream at a time to amortize the block cost. */
>> -#define CSPRNG_BUFSZ    4096
>> -
>> -/* Reseed from the OS entropy pool after this many bytes served, matching
>> - * the arc4random policy of periodic reseeding. */
>> -#define CSPRNG_RESEED   (1600 * 1024)
>>  
>>  #define ROTL32(v, n)    (((v) << (n)) | ((v) >> (32 - (n))))
>>  
>> @@ -147,20 +181,13 @@ random_next(void)
>>      a += b; d ^= a; d = ROTL32(d, 8);           \
>>      c += d; b ^= c; b = ROTL32(b, 7)
>>  
>> -struct csprng {
>> -    uint32_t state[16];             /* ChaCha20 state:
>> -                                     * constant|key|counter|nonce. */
>> -    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
>> -    size_t pos;                     /* Next unused byte in 'buf'. */
>> -    size_t served;                  /* Bytes served since last reseed. */
>> -    int initialized;
>> -};
>> -
>>  /* ChaCha20 constant: "expand 32-byte k".  Must be at least 16 bytes + NUL. */
>>  static const uint8_t chacha_sigma[] = "expand 32-byte k";
>>  
>> +#ifndef HAVE_CHACHA20_EVP
>>  /* Current random state. */
>>  DEFINE_STATIC_PER_THREAD_DATA(struct csprng, cs_state, { .initialized = 0 });
>> +#endif
>>  
>>  /* Produces one 64-byte ChaCha20 block from 'input' (16 words) into 'out'. */
>>  void
>> @@ -211,22 +238,8 @@ csprng_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
>>      }
>>  }
>>  
>> -static void
>> -csprng_seed(struct csprng *c)
>> -{
>> -    uint8_t key[CHACHA_KEYLEN];
>> -
>> -    get_entropy_or_die(key, sizeof key);
>> -    csprng_rekey(c, key);
>> -    ovs_memzero(key, sizeof key);
>> -
>> -    c->pos = sizeof c->buf;
>> -    c->served = 0;
>> -    c->initialized = 1;
>> -}
>> -
>> -/* Fills csprng with fresh keystream, reserving the first 32 bytes to re-key
>> - * the generator (fast key erasure / forward secrecy). */
>> +/* Fills 'c' with fresh keystream, reserving the first 32 bytes to re-key the
>> + * generator (fast key erasure / forward secrecy). */
>
> Nit: This can be rebased into patch 2 of the set.

Yeah, I'll probably restructure them a bit better for the next revision
and try not to move everything around.  Re-reading it, I actually like
the original version more.

>>  static void
>>  csprng_refill(struct csprng *c)
>>  {
>> @@ -246,21 +259,153 @@ csprng_refill(struct csprng *c)
>>      c->pos = CHACHA_KEYLEN;
>>  }
>>  
>> +#ifdef HAVE_CHACHA20_EVP
>> +/* This is the EVP based CSPRNG using the OpenSSL EVP framework to create a
>> + * long stream of bytes, and pull those.  The OpenSSL EVP manages the
>> + * underlying bytes, all this does is manage the policy.  It re-keys from the
>> + * beginning of every refill, as the built-in implementation above does, so
>> + * that both provide the same fast key erasure.
>> + */
>> +
>> +static void
>> +csprng_state_destroy(void *ctx)
>> +{
>> +    struct csprng *csp = ctx;
>> +
>> +    if (csp->ctx) {
>> +        EVP_CIPHER_CTX_free(csp->ctx);
>> +        csp->ctx = NULL;
>> +    }
>> +
>> +    free(csp);
>> +}
>
> Nit: It would be nice if the above and below functions followed the same
> naming convention.

ACK

Thanks!

> - Rosemarie O'Riorden
>
>> +
>> +static struct csprng *
>> +cs_state_get(void)
>> +{
>> +    static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
>> +    static ovsthread_key_t cskey;
>> +    struct csprng *csp;
>> +
>> +    if (ovsthread_once_start(&once)) {
>> +        ovsthread_key_create(&cskey, csprng_state_destroy);
>> +        ovsthread_once_done(&once);
>> +    }
>> +
>> +    csp = ovsthread_getspecific(cskey);
>> +    if (!csp) {
>> +        csp = xzalloc(sizeof *csp);
>> +        csp->use_evp = true;
>> +        ovsthread_setspecific(cskey, csp);
>> +    }
>> +    return csp;
>> +}
>> +
>> +/* (Re)keys the OpenSSL EVP state from 'key' (32 bytes) and 'iv' (16 bytes). */
>> +static bool
>> +csprng_evp_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN],
>> +                 const uint8_t iv[CHACHA_IVLEN])
>> +{
>> +    return EVP_EncryptInit_ex(c->ctx, EVP_chacha20(), NULL, key, iv) == 1;
>> +}
>> +
>> +/* Seeds the OpenSSL EVP state from fresh entropy, returning false if OpenSSL
>> + * cannot provide ChaCha20. */
>> +static bool
>> +csprng_evp_seed(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
>> +{
>> +    uint8_t iv[CHACHA_IVLEN];
>> +    bool ok;
>> +
>> +    if (!c->ctx) {
>> +        c->ctx = EVP_CIPHER_CTX_new();
>> +        if (!c->ctx) {
>> +            VLOG_WARN_ONCE("cs_random: cannot create cipher context.");
>> +            return false;
>> +        }
>> +    }
>> +
>> +    get_entropy_or_die(iv, sizeof iv);
>> +    ok = csprng_evp_rekey(c, key, iv);
>> +    ovs_memzero(iv, sizeof iv);
>> +
>> +    if (!ok) {
>> +        /* OpenSSL may not provide ChaCha20 at all, for example when it only
>> +         * offers approved algorithms in FIPS mode.  Fall back to the built-in
>> +         * implementation rather than failing to provide randomness. */
>> +        VLOG_WARN_ONCE("cs_random: OpenSSL ChaCha20 unavailable, using the "
>> +                       "built-in implementation.");
>> +    }
>> +    return ok;
>> +}
>> +
>> +/* Fills 'c' with fresh keystream from OpenSSL, reserving the first bytes to
>> + * re-key the generator (fast key erasure / forward secrecy). */
>> +static void
>> +csprng_evp_refill(struct csprng *c)
>> +{
>> +    static const uint8_t zero[CSPRNG_BUFSZ];
>> +    int outl;
>> +
>> +    if (EVP_EncryptUpdate(c->ctx, c->buf, &outl, zero, sizeof c->buf) != 1 ||
>> +        outl != sizeof c->buf) {
>> +        VLOG_FATAL("cs_random: EVP fill failure.");
>> +    }
>> +
>> +    csprng_evp_rekey(c, c->buf, c->buf + CHACHA_KEYLEN);
>> +    ovs_memzero(c->buf, CSPRNG_SECRETS);
>> +    c->pos = CSPRNG_SECRETS;
>> +}
>> +#endif /* HAVE_CHACHA20_EVP */
>> +
>> +static void
>> +csprng_seed(struct csprng *c)
>> +{
>> +    uint8_t key[CHACHA_KEYLEN];
>> +
>> +    get_entropy_or_die(key, sizeof key);
>> +
>> +#ifdef HAVE_CHACHA20_EVP
>> +    if (c->use_evp && !csprng_evp_seed(c, key)) {
>> +        c->use_evp = false;
>> +    }
>> +    if (!c->use_evp) {
>> +        csprng_rekey(c, key);
>> +    }
>> +#else
>> +    csprng_rekey(c, key);
>> +#endif
>> +
>> +    ovs_memzero(key, sizeof key);
>> +
>> +    c->pos = sizeof c->buf;
>> +    c->served = 0;
>> +    c->initialized = 1;
>> +}
>> +
>>  void
>>  cs_random_bytes(void *b, size_t l)
>>  {
>>      struct csprng *c = cs_state_get();
>>  
>> -    /* c->buf isn't fully available for reading because the first 32 bytes
>> -     * of every refill are consumed as the next key. */
>> -    ovs_assert(l <= sizeof c->buf - CHACHA_KEYLEN);
>> +    /* c->buf isn't fully available for reading because the first bytes of
>> +     * every refill are consumed as the next key and IV. */
>> +    ovs_assert(l <= sizeof c->buf - CSPRNG_SECRETS);
>>  
>>      if (!c->initialized || c->served >= CSPRNG_RESEED) {
>>          csprng_seed(c);
>>      }
>>  
>>      if (c->pos + l > sizeof c->buf) {
>> +#ifdef HAVE_CHACHA20_EVP
>> +        if (c->use_evp) {
>> +            csprng_evp_refill(c);
>> +        } else {
>> +            csprng_refill(c);
>> +        }
>> +#else
>>          csprng_refill(c);
>> +#endif
>>      }
>>  
>>      memcpy(b, c->buf + c->pos, l);
>> diff --git a/lib/random.h b/lib/random.h
>> index 77792e28f1..76f165c7a8 100644
>> --- a/lib/random.h
>> +++ b/lib/random.h
>> @@ -53,7 +53,7 @@ void chacha20_block(const uint32_t input[CHACHA_K_INPUT],
>>                      uint8_t out[CHACHA_BLOCK]);
>>  
>>  /* Fills 'b' with 'l' cryptographically secure random bytes.  'l' must not be
>> - * larger than 4064; callers needing more bytes should make multiple calls. */
>> + * larger than 4048; callers needing more bytes should make multiple calls. */
>>  void cs_random_bytes(void *, size_t);
>>  uint32_t cs_random_uint32(void);
>>
diff mbox series

Patch

diff --git a/lib/random.c b/lib/random.c
index d2f28866a2..27d57530f7 100644
--- a/lib/random.c
+++ b/lib/random.c
@@ -18,15 +18,24 @@ 
 #include "random.h"
 
 #include <errno.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <sys/time.h>
 
+#if defined(HAVE_OPENSSL) && !defined(OPENSSL_NO_CHACHA)
+#include <openssl/evp.h>
+#define HAVE_CHACHA20_EVP 1
+#endif
+
 #include "byte-order.h"
 #include "entropy.h"
 #include "hash.h"
 #include "ovs-thread.h"
 #include "timeval.h"
 #include "util.h"
+#include "openvswitch/vlog.h"
+
+VLOG_DEFINE_THIS_MODULE(random);
 
 /* This is the 32-bit PRNG recommended in G. Marsaglia, "Xorshift RNGs",
  * _Journal of Statistical Software_ 8:14 (July 2003).  According to the paper,
@@ -120,6 +129,39 @@  random_next(void)
 }
 
 
+/* Cryptographic secure pseudo-random number generator. */
+
+/* Refill a page worth of keystream at a time to amortize the block cost. */
+#define CSPRNG_BUFSZ    4096
+
+#define CHACHA_KEYLEN   32          /* 256-bit key. */
+#define CHACHA_IVLEN    16          /* ChaCha20 IV: counter and nonce. */
+
+/* Reseed from the OS entropy pool after this many bytes served, matching
+ * the arc4random policy of periodic reseeding. */
+#define CSPRNG_RESEED   (1600 * 1024)
+
+#ifdef HAVE_CHACHA20_EVP
+/* The OpenSSL EVP backend consumes an IV in addition to a key. */
+#define CSPRNG_SECRETS  (CHACHA_KEYLEN + CHACHA_IVLEN)
+#else
+#define CSPRNG_SECRETS  CHACHA_KEYLEN
+#endif
+
+struct csprng {
+#ifdef HAVE_CHACHA20_EVP
+    EVP_CIPHER_CTX *ctx;            /* OpenSSL EVP state, once created. */
+    bool use_evp;                   /* Serve from OpenSSL rather than the
+                                     * built-in implementation. */
+#endif
+    uint32_t state[16];             /* ChaCha20 state:
+                                     * constant|key|counter|nonce. */
+    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
+    size_t pos;                     /* Next unused byte in 'buf'. */
+    size_t served;                  /* Bytes served since last reseed. */
+    int initialized;
+};
+
 /* This is a 32-bit CSPRNG adapted from the ChaCha20 algorithm described in
  * RFC 7539 and RFC 8439, similar to arc4random(3) and the Linux kernel's
  * get_random_u32().
@@ -130,14 +172,6 @@  random_next(void)
  */
 
 #define CHACHA_ROUNDS   20
-#define CHACHA_KEYLEN   32          /* 256-bit key. */
-
-/* Refill a page worth of keystream at a time to amortize the block cost. */
-#define CSPRNG_BUFSZ    4096
-
-/* Reseed from the OS entropy pool after this many bytes served, matching
- * the arc4random policy of periodic reseeding. */
-#define CSPRNG_RESEED   (1600 * 1024)
 
 #define ROTL32(v, n)    (((v) << (n)) | ((v) >> (32 - (n))))
 
@@ -147,20 +181,13 @@  random_next(void)
     a += b; d ^= a; d = ROTL32(d, 8);           \
     c += d; b ^= c; b = ROTL32(b, 7)
 
-struct csprng {
-    uint32_t state[16];             /* ChaCha20 state:
-                                     * constant|key|counter|nonce. */
-    uint8_t buf[CSPRNG_BUFSZ];      /* Buffered keystream. */
-    size_t pos;                     /* Next unused byte in 'buf'. */
-    size_t served;                  /* Bytes served since last reseed. */
-    int initialized;
-};
-
 /* ChaCha20 constant: "expand 32-byte k".  Must be at least 16 bytes + NUL. */
 static const uint8_t chacha_sigma[] = "expand 32-byte k";
 
+#ifndef HAVE_CHACHA20_EVP
 /* Current random state. */
 DEFINE_STATIC_PER_THREAD_DATA(struct csprng, cs_state, { .initialized = 0 });
+#endif
 
 /* Produces one 64-byte ChaCha20 block from 'input' (16 words) into 'out'. */
 void
@@ -211,22 +238,8 @@  csprng_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
     }
 }
 
-static void
-csprng_seed(struct csprng *c)
-{
-    uint8_t key[CHACHA_KEYLEN];
-
-    get_entropy_or_die(key, sizeof key);
-    csprng_rekey(c, key);
-    ovs_memzero(key, sizeof key);
-
-    c->pos = sizeof c->buf;
-    c->served = 0;
-    c->initialized = 1;
-}
-
-/* Fills csprng with fresh keystream, reserving the first 32 bytes to re-key
- * the generator (fast key erasure / forward secrecy). */
+/* Fills 'c' with fresh keystream, reserving the first 32 bytes to re-key the
+ * generator (fast key erasure / forward secrecy). */
 static void
 csprng_refill(struct csprng *c)
 {
@@ -246,21 +259,153 @@  csprng_refill(struct csprng *c)
     c->pos = CHACHA_KEYLEN;
 }
 
+#ifdef HAVE_CHACHA20_EVP
+/* This is the EVP based CSPRNG using the OpenSSL EVP framework to create a
+ * long stream of bytes, and pull those.  The OpenSSL EVP manages the
+ * underlying bytes, all this does is manage the policy.  It re-keys from the
+ * beginning of every refill, as the built-in implementation above does, so
+ * that both provide the same fast key erasure.
+ */
+
+static void
+csprng_state_destroy(void *ctx)
+{
+    struct csprng *csp = ctx;
+
+    if (csp->ctx) {
+        EVP_CIPHER_CTX_free(csp->ctx);
+        csp->ctx = NULL;
+    }
+
+    free(csp);
+}
+
+static struct csprng *
+cs_state_get(void)
+{
+    static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
+    static ovsthread_key_t cskey;
+    struct csprng *csp;
+
+    if (ovsthread_once_start(&once)) {
+        ovsthread_key_create(&cskey, csprng_state_destroy);
+        ovsthread_once_done(&once);
+    }
+
+    csp = ovsthread_getspecific(cskey);
+    if (!csp) {
+        csp = xzalloc(sizeof *csp);
+        csp->use_evp = true;
+        ovsthread_setspecific(cskey, csp);
+    }
+    return csp;
+}
+
+/* (Re)keys the OpenSSL EVP state from 'key' (32 bytes) and 'iv' (16 bytes). */
+static bool
+csprng_evp_rekey(struct csprng *c, const uint8_t key[CHACHA_KEYLEN],
+                 const uint8_t iv[CHACHA_IVLEN])
+{
+    return EVP_EncryptInit_ex(c->ctx, EVP_chacha20(), NULL, key, iv) == 1;
+}
+
+/* Seeds the OpenSSL EVP state from fresh entropy, returning false if OpenSSL
+ * cannot provide ChaCha20. */
+static bool
+csprng_evp_seed(struct csprng *c, const uint8_t key[CHACHA_KEYLEN])
+{
+    uint8_t iv[CHACHA_IVLEN];
+    bool ok;
+
+    if (!c->ctx) {
+        c->ctx = EVP_CIPHER_CTX_new();
+        if (!c->ctx) {
+            VLOG_WARN_ONCE("cs_random: cannot create cipher context.");
+            return false;
+        }
+    }
+
+    get_entropy_or_die(iv, sizeof iv);
+    ok = csprng_evp_rekey(c, key, iv);
+    ovs_memzero(iv, sizeof iv);
+
+    if (!ok) {
+        /* OpenSSL may not provide ChaCha20 at all, for example when it only
+         * offers approved algorithms in FIPS mode.  Fall back to the built-in
+         * implementation rather than failing to provide randomness. */
+        VLOG_WARN_ONCE("cs_random: OpenSSL ChaCha20 unavailable, using the "
+                       "built-in implementation.");
+    }
+    return ok;
+}
+
+/* Fills 'c' with fresh keystream from OpenSSL, reserving the first bytes to
+ * re-key the generator (fast key erasure / forward secrecy). */
+static void
+csprng_evp_refill(struct csprng *c)
+{
+    static const uint8_t zero[CSPRNG_BUFSZ];
+    int outl;
+
+    if (EVP_EncryptUpdate(c->ctx, c->buf, &outl, zero, sizeof c->buf) != 1 ||
+        outl != sizeof c->buf) {
+        VLOG_FATAL("cs_random: EVP fill failure.");
+    }
+
+    csprng_evp_rekey(c, c->buf, c->buf + CHACHA_KEYLEN);
+    ovs_memzero(c->buf, CSPRNG_SECRETS);
+    c->pos = CSPRNG_SECRETS;
+}
+#endif /* HAVE_CHACHA20_EVP */
+
+static void
+csprng_seed(struct csprng *c)
+{
+    uint8_t key[CHACHA_KEYLEN];
+
+    get_entropy_or_die(key, sizeof key);
+
+#ifdef HAVE_CHACHA20_EVP
+    if (c->use_evp && !csprng_evp_seed(c, key)) {
+        c->use_evp = false;
+    }
+    if (!c->use_evp) {
+        csprng_rekey(c, key);
+    }
+#else
+    csprng_rekey(c, key);
+#endif
+
+    ovs_memzero(key, sizeof key);
+
+    c->pos = sizeof c->buf;
+    c->served = 0;
+    c->initialized = 1;
+}
+
 void
 cs_random_bytes(void *b, size_t l)
 {
     struct csprng *c = cs_state_get();
 
-    /* c->buf isn't fully available for reading because the first 32 bytes
-     * of every refill are consumed as the next key. */
-    ovs_assert(l <= sizeof c->buf - CHACHA_KEYLEN);
+    /* c->buf isn't fully available for reading because the first bytes of
+     * every refill are consumed as the next key and IV. */
+    ovs_assert(l <= sizeof c->buf - CSPRNG_SECRETS);
 
     if (!c->initialized || c->served >= CSPRNG_RESEED) {
         csprng_seed(c);
     }
 
     if (c->pos + l > sizeof c->buf) {
+#ifdef HAVE_CHACHA20_EVP
+        if (c->use_evp) {
+            csprng_evp_refill(c);
+        } else {
+            csprng_refill(c);
+        }
+#else
         csprng_refill(c);
+#endif
     }
 
     memcpy(b, c->buf + c->pos, l);
diff --git a/lib/random.h b/lib/random.h
index 77792e28f1..76f165c7a8 100644
--- a/lib/random.h
+++ b/lib/random.h
@@ -53,7 +53,7 @@  void chacha20_block(const uint32_t input[CHACHA_K_INPUT],
                     uint8_t out[CHACHA_BLOCK]);
 
 /* Fills 'b' with 'l' cryptographically secure random bytes.  'l' must not be
- * larger than 4064; callers needing more bytes should make multiple calls. */
+ * larger than 4048; callers needing more bytes should make multiple calls. */
 void cs_random_bytes(void *, size_t);
 uint32_t cs_random_uint32(void);