~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/crypto/rng.h

Version: ~ [ linux-6.1-rc7 ] ~ [ linux-6.0.10 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.80 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.156 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.225 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.267 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.300 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.334 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * RNG: Random Number Generator  algorithms under the crypto API
  3  *
  4  * Copyright (c) 2008 Neil Horman <nhorman@tuxdriver.com>
  5  * Copyright (c) 2015 Herbert Xu <herbert@gondor.apana.org.au>
  6  *
  7  * This program is free software; you can redistribute it and/or modify it
  8  * under the terms of the GNU General Public License as published by the Free
  9  * Software Foundation; either version 2 of the License, or (at your option)
 10  * any later version.
 11  *
 12  */
 13 
 14 #ifndef _CRYPTO_RNG_H
 15 #define _CRYPTO_RNG_H
 16 
 17 #include <linux/crypto.h>
 18 
 19 struct crypto_rng;
 20 
 21 /**
 22  * struct rng_alg - random number generator definition
 23  *
 24  * @generate:   The function defined by this variable obtains a
 25  *              random number. The random number generator transform
 26  *              must generate the random number out of the context
 27  *              provided with this call, plus any additional data
 28  *              if provided to the call.
 29  * @seed:       Seed or reseed the random number generator.  With the
 30  *              invocation of this function call, the random number
 31  *              generator shall become ready for generation.  If the
 32  *              random number generator requires a seed for setting
 33  *              up a new state, the seed must be provided by the
 34  *              consumer while invoking this function. The required
 35  *              size of the seed is defined with @seedsize .
 36  * @set_ent:    Set entropy that would otherwise be obtained from
 37  *              entropy source.  Internal use only.
 38  * @seedsize:   The seed size required for a random number generator
 39  *              initialization defined with this variable. Some
 40  *              random number generators does not require a seed
 41  *              as the seeding is implemented internally without
 42  *              the need of support by the consumer. In this case,
 43  *              the seed size is set to zero.
 44  * @base:       Common crypto API algorithm data structure.
 45  */
 46 struct rng_alg {
 47         int (*generate)(struct crypto_rng *tfm,
 48                         const u8 *src, unsigned int slen,
 49                         u8 *dst, unsigned int dlen);
 50         int (*seed)(struct crypto_rng *tfm, const u8 *seed, unsigned int slen);
 51         void (*set_ent)(struct crypto_rng *tfm, const u8 *data,
 52                         unsigned int len);
 53 
 54         unsigned int seedsize;
 55 
 56         struct crypto_alg base;
 57 };
 58 
 59 struct crypto_rng {
 60         struct crypto_tfm base;
 61 };
 62 
 63 extern struct crypto_rng *crypto_default_rng;
 64 
 65 int crypto_get_default_rng(void);
 66 void crypto_put_default_rng(void);
 67 
 68 /**
 69  * DOC: Random number generator API
 70  *
 71  * The random number generator API is used with the ciphers of type
 72  * CRYPTO_ALG_TYPE_RNG (listed as type "rng" in /proc/crypto)
 73  */
 74 
 75 /**
 76  * crypto_alloc_rng() -- allocate RNG handle
 77  * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
 78  *            message digest cipher
 79  * @type: specifies the type of the cipher
 80  * @mask: specifies the mask for the cipher
 81  *
 82  * Allocate a cipher handle for a random number generator. The returned struct
 83  * crypto_rng is the cipher handle that is required for any subsequent
 84  * API invocation for that random number generator.
 85  *
 86  * For all random number generators, this call creates a new private copy of
 87  * the random number generator that does not share a state with other
 88  * instances. The only exception is the "krng" random number generator which
 89  * is a kernel crypto API use case for the get_random_bytes() function of the
 90  * /dev/random driver.
 91  *
 92  * Return: allocated cipher handle in case of success; IS_ERR() is true in case
 93  *         of an error, PTR_ERR() returns the error code.
 94  */
 95 struct crypto_rng *crypto_alloc_rng(const char *alg_name, u32 type, u32 mask);
 96 
 97 static inline struct crypto_tfm *crypto_rng_tfm(struct crypto_rng *tfm)
 98 {
 99         return &tfm->base;
100 }
101 
102 /**
103  * crypto_rng_alg - obtain name of RNG
104  * @tfm: cipher handle
105  *
106  * Return the generic name (cra_name) of the initialized random number generator
107  *
108  * Return: generic name string
109  */
110 static inline struct rng_alg *crypto_rng_alg(struct crypto_rng *tfm)
111 {
112         return container_of(crypto_rng_tfm(tfm)->__crt_alg,
113                             struct rng_alg, base);
114 }
115 
116 /**
117  * crypto_free_rng() - zeroize and free RNG handle
118  * @tfm: cipher handle to be freed
119  */
120 static inline void crypto_free_rng(struct crypto_rng *tfm)
121 {
122         crypto_destroy_tfm(tfm, crypto_rng_tfm(tfm));
123 }
124 
125 /**
126  * crypto_rng_generate() - get random number
127  * @tfm: cipher handle
128  * @src: Input buffer holding additional data, may be NULL
129  * @slen: Length of additional data
130  * @dst: output buffer holding the random numbers
131  * @dlen: length of the output buffer
132  *
133  * This function fills the caller-allocated buffer with random
134  * numbers using the random number generator referenced by the
135  * cipher handle.
136  *
137  * Return: 0 function was successful; < 0 if an error occurred
138  */
139 static inline int crypto_rng_generate(struct crypto_rng *tfm,
140                                       const u8 *src, unsigned int slen,
141                                       u8 *dst, unsigned int dlen)
142 {
143         return crypto_rng_alg(tfm)->generate(tfm, src, slen, dst, dlen);
144 }
145 
146 /**
147  * crypto_rng_get_bytes() - get random number
148  * @tfm: cipher handle
149  * @rdata: output buffer holding the random numbers
150  * @dlen: length of the output buffer
151  *
152  * This function fills the caller-allocated buffer with random numbers using the
153  * random number generator referenced by the cipher handle.
154  *
155  * Return: 0 function was successful; < 0 if an error occurred
156  */
157 static inline int crypto_rng_get_bytes(struct crypto_rng *tfm,
158                                        u8 *rdata, unsigned int dlen)
159 {
160         return crypto_rng_generate(tfm, NULL, 0, rdata, dlen);
161 }
162 
163 /**
164  * crypto_rng_reset() - re-initialize the RNG
165  * @tfm: cipher handle
166  * @seed: seed input data
167  * @slen: length of the seed input data
168  *
169  * The reset function completely re-initializes the random number generator
170  * referenced by the cipher handle by clearing the current state. The new state
171  * is initialized with the caller provided seed or automatically, depending
172  * on the random number generator type (the ANSI X9.31 RNG requires
173  * caller-provided seed, the SP800-90A DRBGs perform an automatic seeding).
174  * The seed is provided as a parameter to this function call. The provided seed
175  * should have the length of the seed size defined for the random number
176  * generator as defined by crypto_rng_seedsize.
177  *
178  * Return: 0 if the setting of the key was successful; < 0 if an error occurred
179  */
180 int crypto_rng_reset(struct crypto_rng *tfm, const u8 *seed,
181                      unsigned int slen);
182 
183 /**
184  * crypto_rng_seedsize() - obtain seed size of RNG
185  * @tfm: cipher handle
186  *
187  * The function returns the seed size for the random number generator
188  * referenced by the cipher handle. This value may be zero if the random
189  * number generator does not implement or require a reseeding. For example,
190  * the SP800-90A DRBGs implement an automated reseeding after reaching a
191  * pre-defined threshold.
192  *
193  * Return: seed size for the random number generator
194  */
195 static inline int crypto_rng_seedsize(struct crypto_rng *tfm)
196 {
197         return crypto_rng_alg(tfm)->seedsize;
198 }
199 
200 #endif
201 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp