1 // SPDX-License-Identifier: GPL-2.0-or-later
7 * Copyright (c) 2008 Neil Horman <nhorman@tuxdriver.com>
8 * Copyright (c) 2015 Herbert Xu <herbert@gondor.apana.org.au>
11 #include <crypto/internal/rng.h>
12 #include <linux/atomic.h>
13 #include <linux/cryptouser.h>
14 #include <linux/err.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/mutex.h>
18 #include <linux/random.h>
19 #include <linux/seq_file.h>
20 #include <linux/slab.h>
21 #include <linux/string.h>
22 #include <net/netlink.h>
26 static DEFINE_MUTEX(crypto_default_rng_lock
);
27 struct crypto_rng
*crypto_default_rng
;
28 EXPORT_SYMBOL_GPL(crypto_default_rng
);
29 static int crypto_default_rng_refcnt
;
31 int crypto_rng_reset(struct crypto_rng
*tfm
, const u8
*seed
, unsigned int slen
)
33 struct rng_alg
*alg
= crypto_rng_alg(tfm
);
37 if (IS_ENABLED(CONFIG_CRYPTO_STATS
))
38 atomic64_inc(&rng_get_stat(alg
)->seed_cnt
);
41 buf
= kmalloc(slen
, GFP_KERNEL
);
46 err
= get_random_bytes_wait(buf
, slen
);
52 err
= alg
->seed(tfm
, seed
, slen
);
56 return crypto_rng_errstat(alg
, err
);
58 EXPORT_SYMBOL_GPL(crypto_rng_reset
);
60 static int crypto_rng_init_tfm(struct crypto_tfm
*tfm
)
65 static unsigned int seedsize(struct crypto_alg
*alg
)
67 struct rng_alg
*ralg
= container_of(alg
, struct rng_alg
, base
);
69 return ralg
->seedsize
;
72 static int __maybe_unused
crypto_rng_report(
73 struct sk_buff
*skb
, struct crypto_alg
*alg
)
75 struct crypto_report_rng rrng
;
77 memset(&rrng
, 0, sizeof(rrng
));
79 strscpy(rrng
.type
, "rng", sizeof(rrng
.type
));
81 rrng
.seedsize
= seedsize(alg
);
83 return nla_put(skb
, CRYPTOCFGA_REPORT_RNG
, sizeof(rrng
), &rrng
);
86 static void crypto_rng_show(struct seq_file
*m
, struct crypto_alg
*alg
)
88 static void crypto_rng_show(struct seq_file
*m
, struct crypto_alg
*alg
)
90 seq_printf(m
, "type : rng\n");
91 seq_printf(m
, "seedsize : %u\n", seedsize(alg
));
94 static int __maybe_unused
crypto_rng_report_stat(
95 struct sk_buff
*skb
, struct crypto_alg
*alg
)
97 struct rng_alg
*rng
= __crypto_rng_alg(alg
);
98 struct crypto_istat_rng
*istat
;
99 struct crypto_stat_rng rrng
;
101 istat
= rng_get_stat(rng
);
103 memset(&rrng
, 0, sizeof(rrng
));
105 strscpy(rrng
.type
, "rng", sizeof(rrng
.type
));
107 rrng
.stat_generate_cnt
= atomic64_read(&istat
->generate_cnt
);
108 rrng
.stat_generate_tlen
= atomic64_read(&istat
->generate_tlen
);
109 rrng
.stat_seed_cnt
= atomic64_read(&istat
->seed_cnt
);
110 rrng
.stat_err_cnt
= atomic64_read(&istat
->err_cnt
);
112 return nla_put(skb
, CRYPTOCFGA_STAT_RNG
, sizeof(rrng
), &rrng
);
115 static const struct crypto_type crypto_rng_type
= {
116 .extsize
= crypto_alg_extsize
,
117 .init_tfm
= crypto_rng_init_tfm
,
118 #ifdef CONFIG_PROC_FS
119 .show
= crypto_rng_show
,
121 #if IS_ENABLED(CONFIG_CRYPTO_USER)
122 .report
= crypto_rng_report
,
124 #ifdef CONFIG_CRYPTO_STATS
125 .report_stat
= crypto_rng_report_stat
,
127 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
128 .maskset
= CRYPTO_ALG_TYPE_MASK
,
129 .type
= CRYPTO_ALG_TYPE_RNG
,
130 .tfmsize
= offsetof(struct crypto_rng
, base
),
133 struct crypto_rng
*crypto_alloc_rng(const char *alg_name
, u32 type
, u32 mask
)
135 return crypto_alloc_tfm(alg_name
, &crypto_rng_type
, type
, mask
);
137 EXPORT_SYMBOL_GPL(crypto_alloc_rng
);
139 int crypto_get_default_rng(void)
141 struct crypto_rng
*rng
;
144 mutex_lock(&crypto_default_rng_lock
);
145 if (!crypto_default_rng
) {
146 rng
= crypto_alloc_rng("stdrng", 0, 0);
151 err
= crypto_rng_reset(rng
, NULL
, crypto_rng_seedsize(rng
));
153 crypto_free_rng(rng
);
157 crypto_default_rng
= rng
;
160 crypto_default_rng_refcnt
++;
164 mutex_unlock(&crypto_default_rng_lock
);
168 EXPORT_SYMBOL_GPL(crypto_get_default_rng
);
170 void crypto_put_default_rng(void)
172 mutex_lock(&crypto_default_rng_lock
);
173 crypto_default_rng_refcnt
--;
174 mutex_unlock(&crypto_default_rng_lock
);
176 EXPORT_SYMBOL_GPL(crypto_put_default_rng
);
178 #if defined(CONFIG_CRYPTO_RNG) || defined(CONFIG_CRYPTO_RNG_MODULE)
179 int crypto_del_default_rng(void)
183 mutex_lock(&crypto_default_rng_lock
);
184 if (crypto_default_rng_refcnt
)
187 crypto_free_rng(crypto_default_rng
);
188 crypto_default_rng
= NULL
;
193 mutex_unlock(&crypto_default_rng_lock
);
197 EXPORT_SYMBOL_GPL(crypto_del_default_rng
);
200 int crypto_register_rng(struct rng_alg
*alg
)
202 struct crypto_istat_rng
*istat
= rng_get_stat(alg
);
203 struct crypto_alg
*base
= &alg
->base
;
205 if (alg
->seedsize
> PAGE_SIZE
/ 8)
208 base
->cra_type
= &crypto_rng_type
;
209 base
->cra_flags
&= ~CRYPTO_ALG_TYPE_MASK
;
210 base
->cra_flags
|= CRYPTO_ALG_TYPE_RNG
;
212 if (IS_ENABLED(CONFIG_CRYPTO_STATS
))
213 memset(istat
, 0, sizeof(*istat
));
215 return crypto_register_alg(base
);
217 EXPORT_SYMBOL_GPL(crypto_register_rng
);
219 void crypto_unregister_rng(struct rng_alg
*alg
)
221 crypto_unregister_alg(&alg
->base
);
223 EXPORT_SYMBOL_GPL(crypto_unregister_rng
);
225 int crypto_register_rngs(struct rng_alg
*algs
, int count
)
229 for (i
= 0; i
< count
; i
++) {
230 ret
= crypto_register_rng(algs
+ i
);
238 for (--i
; i
>= 0; --i
)
239 crypto_unregister_rng(algs
+ i
);
243 EXPORT_SYMBOL_GPL(crypto_register_rngs
);
245 void crypto_unregister_rngs(struct rng_alg
*algs
, int count
)
249 for (i
= count
- 1; i
>= 0; --i
)
250 crypto_unregister_rng(algs
+ i
);
252 EXPORT_SYMBOL_GPL(crypto_unregister_rngs
);
254 MODULE_LICENSE("GPL");
255 MODULE_DESCRIPTION("Random Number Generator");