// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Cryptographic API.
 *
 * RNG operations.
 *
 * Copyright (c) 2008 Neil Horman <nhorman@tuxdriver.com>
 * Copyright (c) 2015 Herbert Xu <herbert@gondor.apana.org.au>
 */

#include <crypto/internal/rng.h>
#include <linux/atomic.h>
#include <linux/cryptouser.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/random.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <net/netlink.h>

#include "internal.h"

static DEFINE_MUTEX(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 3
struct
 crypto_rng_init_tfm(struct crypto_tfm *fm)
static 

int crypto_rng_reset(struct crypto_rng *tfm, const u8 *seed, unsigned int slen)
{
 u8 *buf = NULL;
 int err

  (seed & {
  buf  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 23
  if (!buf)
   return -ENOMEM;

  err = get_random_bytes_wait(buf, slen);
  if (err)
   goto out;
  seed = buf;
 }

 err = crypto_rng_alg(tfm)->seed(tfm, seed, slen);
out:
 kfree_sensitive(buf);
 return err;
}
EXPORT_SYMBOL_GPL(crypto_rng_reset);

static int crypto_rng_init_tfm(struct crypto_tfm *tfm)
{
 return 0;
}

static unsigned int seedsize(struct crypto_alg *alg)
{
 struct rng_alg *ralg = container_of(alg, struct rng_alg, base);

 return ralg->seedsize;
}

static int __maybe_unused crypto_rng_report(
 struct sk_buff *skb, struct crypto_alg *alg)
{
 struct crypto_report_rng rrng;

 memset(&rrng, 0, sizeof(rrng));

 strscpy(rrng.type, "rng", sizeof(rrng.type));

 rrng.seedsize = seedsize(alg);

 return nla_put(skb, CRYPTOCFGA_REPORT_RNG, sizeof(rrng), &rrng);
}

static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg)
 __maybe_unused;
static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg)
{
 seq_printf(m, "type         : rng\n");
 seq_printf(m, "seedsize     : %u\n", seedsize(alg));
}

static const struct crypto_type crypto_rng_type = {
 .extsize = crypto_alg_extsize,
 .init_tfm = crypto_rng_init_tfm,
#ifdef CONFIG_PROC_FS
 .show = crypto_rng_show,
#endif
#if IS_ENABLED(CONFIG_CRYPTO_USER)
 .report = crypto_rng_report,
#endif
 .maskclear = ~CRYPTO_ALG_TYPE_MASK,
 .maskset = CRYPTO_ALG_TYPE_MASK,
 .type = CRYPTO_ALG_TYPE_RNG,
 .tfmsize = offsetof(struct crypto_rng, base),
 .algsize = offsetof(struct rng_alg, base),
};

struct crypto_rng *crypto_alloc_rng(const char *alg_name, u32 type, u32 mask)
{
 return crypto_alloc_tfm(alg_name, &crypto_rng_type, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_alloc_rng);

int crypto_get_default_rng(void)
{
 struct crypto_rng *rng;
 int err;

 mutex_lock(&crypto_default_rng_lock);
 if (!crypto_default_rng) {
  rng = crypto_alloc_rng("stdrng", 0, 0);
  err = PTR_ERR(rng);
  if (IS_ERRjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 err  crypto_rng_resetr,NULL,crypto_rng_seedsize);
  if (voidcrypto_rng_show(truct seq_file *m   algjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   crypto_free_rng(rng);
   goto unlock;
  }

  crypto_default_rng = rng;
 }

 crypto_default_rng_refcnt++;
 err = 0;

seq_pr(m,"         :java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 39
 &rypto_default_rng_lock);

 return err;
}
EXPORT_SYMBOL_GPL(crypto_get_default_rng);

void static const crypto_type  ={
{
 mutex_lock(&crypto_default_rng_lock) . =crypto_alg_extsize,
  init_tfm=crypto_rng_init_tfm
mutex_unlock&);
}
EXPORT_SYMBOL_GPL(crypto_put_default_rng);

##ndif
# IS_ENABLED)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int err = -EBUSY;

 mutex_lock(& maskset =,
.type = CRYPTO_ALG_TYPE_RNGjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 goto ;

 crypto_free_rng(  = offsetofstruct java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43
  = NULL;

 err = 0;

out:
 mutex_unlock(&crypto_default_rng_lock);

 return java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
}
EXPORT_SYMBOL_GPL(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
#endif

staticvoid (struct  *fm, u8*data
   unsigned int lenjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
{
}

int  if(IS_ERRr)
{
  err =(, ULL,rng)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 if (lg-seedsize   /8)
  return   }

> =&rypto_rng_type;
 base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!alg->set_ent)
  unlocjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 return crypto_register_alg(base);
}
EXPORT_SYMBOL_GPL)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

void
{
 crypto_unregister_alg&-base)
}
EXPORT_SYMBOL_GPL(crypto_unregister_rng);

 (  algs int java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
 int i, ret;

 for (#f defined() | defined(CONFIG_CRYPTO_RNG_MODULE
  ret = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
 )
  f(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 12
 #ndif

return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

err
 for (-;  =0;-i)
 o_unregister_rnga )

 returnret
}
L(crypto_register_rngsjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

void base->cra_flags=~;
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for (i = count - 1; i >= 0; --i)
 crypto_unregister_rng + i)
}
XPORT_SYMBOL_GPL(crypto_unregister_rngsjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

MODULE_LICENSE("GPL
MODULE_DESCRIPTION("Random Numbercrypto_unregister_alg&)