LCOV - code coverage report
Current view: top level - crypto - drbg.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 47 418 11.2 %
Date: 2022-04-01 13:59:58 Functions: 2 24 8.3 %
Branches: 6 219 2.7 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * DRBG: Deterministic Random Bits Generator
       3                 :            :  *       Based on NIST Recommended DRBG from NIST SP800-90A with the following
       4                 :            :  *       properties:
       5                 :            :  *              * CTR DRBG with DF with AES-128, AES-192, AES-256 cores
       6                 :            :  *              * Hash DRBG with DF with SHA-1, SHA-256, SHA-384, SHA-512 cores
       7                 :            :  *              * HMAC DRBG with DF with SHA-1, SHA-256, SHA-384, SHA-512 cores
       8                 :            :  *              * with and without prediction resistance
       9                 :            :  *
      10                 :            :  * Copyright Stephan Mueller <smueller@chronox.de>, 2014
      11                 :            :  *
      12                 :            :  * Redistribution and use in source and binary forms, with or without
      13                 :            :  * modification, are permitted provided that the following conditions
      14                 :            :  * are met:
      15                 :            :  * 1. Redistributions of source code must retain the above copyright
      16                 :            :  *    notice, and the entire permission notice in its entirety,
      17                 :            :  *    including the disclaimer of warranties.
      18                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      19                 :            :  *    notice, this list of conditions and the following disclaimer in the
      20                 :            :  *    documentation and/or other materials provided with the distribution.
      21                 :            :  * 3. The name of the author may not be used to endorse or promote
      22                 :            :  *    products derived from this software without specific prior
      23                 :            :  *    written permission.
      24                 :            :  *
      25                 :            :  * ALTERNATIVELY, this product may be distributed under the terms of
      26                 :            :  * the GNU General Public License, in which case the provisions of the GPL are
      27                 :            :  * required INSTEAD OF the above restrictions.  (This clause is
      28                 :            :  * necessary due to a potential bad interaction between the GPL and
      29                 :            :  * the restrictions contained in a BSD-style copyright.)
      30                 :            :  *
      31                 :            :  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
      32                 :            :  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
      33                 :            :  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
      34                 :            :  * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
      35                 :            :  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
      36                 :            :  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
      37                 :            :  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
      38                 :            :  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
      39                 :            :  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      40                 :            :  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
      41                 :            :  * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
      42                 :            :  * DAMAGE.
      43                 :            :  *
      44                 :            :  * DRBG Usage
      45                 :            :  * ==========
      46                 :            :  * The SP 800-90A DRBG allows the user to specify a personalization string
      47                 :            :  * for initialization as well as an additional information string for each
      48                 :            :  * random number request. The following code fragments show how a caller
      49                 :            :  * uses the kernel crypto API to use the full functionality of the DRBG.
      50                 :            :  *
      51                 :            :  * Usage without any additional data
      52                 :            :  * ---------------------------------
      53                 :            :  * struct crypto_rng *drng;
      54                 :            :  * int err;
      55                 :            :  * char data[DATALEN];
      56                 :            :  *
      57                 :            :  * drng = crypto_alloc_rng(drng_name, 0, 0);
      58                 :            :  * err = crypto_rng_get_bytes(drng, &data, DATALEN);
      59                 :            :  * crypto_free_rng(drng);
      60                 :            :  *
      61                 :            :  *
      62                 :            :  * Usage with personalization string during initialization
      63                 :            :  * -------------------------------------------------------
      64                 :            :  * struct crypto_rng *drng;
      65                 :            :  * int err;
      66                 :            :  * char data[DATALEN];
      67                 :            :  * struct drbg_string pers;
      68                 :            :  * char personalization[11] = "some-string";
      69                 :            :  *
      70                 :            :  * drbg_string_fill(&pers, personalization, strlen(personalization));
      71                 :            :  * drng = crypto_alloc_rng(drng_name, 0, 0);
      72                 :            :  * // The reset completely re-initializes the DRBG with the provided
      73                 :            :  * // personalization string
      74                 :            :  * err = crypto_rng_reset(drng, &personalization, strlen(personalization));
      75                 :            :  * err = crypto_rng_get_bytes(drng, &data, DATALEN);
      76                 :            :  * crypto_free_rng(drng);
      77                 :            :  *
      78                 :            :  *
      79                 :            :  * Usage with additional information string during random number request
      80                 :            :  * ---------------------------------------------------------------------
      81                 :            :  * struct crypto_rng *drng;
      82                 :            :  * int err;
      83                 :            :  * char data[DATALEN];
      84                 :            :  * char addtl_string[11] = "some-string";
      85                 :            :  * string drbg_string addtl;
      86                 :            :  *
      87                 :            :  * drbg_string_fill(&addtl, addtl_string, strlen(addtl_string));
      88                 :            :  * drng = crypto_alloc_rng(drng_name, 0, 0);
      89                 :            :  * // The following call is a wrapper to crypto_rng_get_bytes() and returns
      90                 :            :  * // the same error codes.
      91                 :            :  * err = crypto_drbg_get_bytes_addtl(drng, &data, DATALEN, &addtl);
      92                 :            :  * crypto_free_rng(drng);
      93                 :            :  *
      94                 :            :  *
      95                 :            :  * Usage with personalization and additional information strings
      96                 :            :  * -------------------------------------------------------------
      97                 :            :  * Just mix both scenarios above.
      98                 :            :  */
      99                 :            : 
     100                 :            : #include <crypto/drbg.h>
     101                 :            : #include <linux/kernel.h>
     102                 :            : 
     103                 :            : /***************************************************************
     104                 :            :  * Backend cipher definitions available to DRBG
     105                 :            :  ***************************************************************/
     106                 :            : 
     107                 :            : /*
     108                 :            :  * The order of the DRBG definitions here matter: every DRBG is registered
     109                 :            :  * as stdrng. Each DRBG receives an increasing cra_priority values the later
     110                 :            :  * they are defined in this array (see drbg_fill_array).
     111                 :            :  *
     112                 :            :  * HMAC DRBGs are favored over Hash DRBGs over CTR DRBGs, and
     113                 :            :  * the SHA256 / AES 256 over other ciphers. Thus, the favored
     114                 :            :  * DRBGs are the latest entries in this array.
     115                 :            :  */
     116                 :            : static const struct drbg_core drbg_cores[] = {
     117                 :            : #ifdef CONFIG_CRYPTO_DRBG_CTR
     118                 :            :         {
     119                 :            :                 .flags = DRBG_CTR | DRBG_STRENGTH128,
     120                 :            :                 .statelen = 32, /* 256 bits as defined in 10.2.1 */
     121                 :            :                 .blocklen_bytes = 16,
     122                 :            :                 .cra_name = "ctr_aes128",
     123                 :            :                 .backend_cra_name = "aes",
     124                 :            :         }, {
     125                 :            :                 .flags = DRBG_CTR | DRBG_STRENGTH192,
     126                 :            :                 .statelen = 40, /* 320 bits as defined in 10.2.1 */
     127                 :            :                 .blocklen_bytes = 16,
     128                 :            :                 .cra_name = "ctr_aes192",
     129                 :            :                 .backend_cra_name = "aes",
     130                 :            :         }, {
     131                 :            :                 .flags = DRBG_CTR | DRBG_STRENGTH256,
     132                 :            :                 .statelen = 48, /* 384 bits as defined in 10.2.1 */
     133                 :            :                 .blocklen_bytes = 16,
     134                 :            :                 .cra_name = "ctr_aes256",
     135                 :            :                 .backend_cra_name = "aes",
     136                 :            :         },
     137                 :            : #endif /* CONFIG_CRYPTO_DRBG_CTR */
     138                 :            : #ifdef CONFIG_CRYPTO_DRBG_HASH
     139                 :            :         {
     140                 :            :                 .flags = DRBG_HASH | DRBG_STRENGTH128,
     141                 :            :                 .statelen = 55, /* 440 bits */
     142                 :            :                 .blocklen_bytes = 20,
     143                 :            :                 .cra_name = "sha1",
     144                 :            :                 .backend_cra_name = "sha1",
     145                 :            :         }, {
     146                 :            :                 .flags = DRBG_HASH | DRBG_STRENGTH256,
     147                 :            :                 .statelen = 111, /* 888 bits */
     148                 :            :                 .blocklen_bytes = 48,
     149                 :            :                 .cra_name = "sha384",
     150                 :            :                 .backend_cra_name = "sha384",
     151                 :            :         }, {
     152                 :            :                 .flags = DRBG_HASH | DRBG_STRENGTH256,
     153                 :            :                 .statelen = 111, /* 888 bits */
     154                 :            :                 .blocklen_bytes = 64,
     155                 :            :                 .cra_name = "sha512",
     156                 :            :                 .backend_cra_name = "sha512",
     157                 :            :         }, {
     158                 :            :                 .flags = DRBG_HASH | DRBG_STRENGTH256,
     159                 :            :                 .statelen = 55, /* 440 bits */
     160                 :            :                 .blocklen_bytes = 32,
     161                 :            :                 .cra_name = "sha256",
     162                 :            :                 .backend_cra_name = "sha256",
     163                 :            :         },
     164                 :            : #endif /* CONFIG_CRYPTO_DRBG_HASH */
     165                 :            : #ifdef CONFIG_CRYPTO_DRBG_HMAC
     166                 :            :         {
     167                 :            :                 .flags = DRBG_HMAC | DRBG_STRENGTH128,
     168                 :            :                 .statelen = 20, /* block length of cipher */
     169                 :            :                 .blocklen_bytes = 20,
     170                 :            :                 .cra_name = "hmac_sha1",
     171                 :            :                 .backend_cra_name = "hmac(sha1)",
     172                 :            :         }, {
     173                 :            :                 .flags = DRBG_HMAC | DRBG_STRENGTH256,
     174                 :            :                 .statelen = 48, /* block length of cipher */
     175                 :            :                 .blocklen_bytes = 48,
     176                 :            :                 .cra_name = "hmac_sha384",
     177                 :            :                 .backend_cra_name = "hmac(sha384)",
     178                 :            :         }, {
     179                 :            :                 .flags = DRBG_HMAC | DRBG_STRENGTH256,
     180                 :            :                 .statelen = 64, /* block length of cipher */
     181                 :            :                 .blocklen_bytes = 64,
     182                 :            :                 .cra_name = "hmac_sha512",
     183                 :            :                 .backend_cra_name = "hmac(sha512)",
     184                 :            :         }, {
     185                 :            :                 .flags = DRBG_HMAC | DRBG_STRENGTH256,
     186                 :            :                 .statelen = 32, /* block length of cipher */
     187                 :            :                 .blocklen_bytes = 32,
     188                 :            :                 .cra_name = "hmac_sha256",
     189                 :            :                 .backend_cra_name = "hmac(sha256)",
     190                 :            :         },
     191                 :            : #endif /* CONFIG_CRYPTO_DRBG_HMAC */
     192                 :            : };
     193                 :            : 
     194                 :            : static int drbg_uninstantiate(struct drbg_state *drbg);
     195                 :            : 
     196                 :            : /******************************************************************
     197                 :            :  * Generic helper functions
     198                 :            :  ******************************************************************/
     199                 :            : 
     200                 :            : /*
     201                 :            :  * Return strength of DRBG according to SP800-90A section 8.4
     202                 :            :  *
     203                 :            :  * @flags DRBG flags reference
     204                 :            :  *
     205                 :            :  * Return: normalized strength in *bytes* value or 32 as default
     206                 :            :  *         to counter programming errors
     207                 :            :  */
     208                 :          0 : static inline unsigned short drbg_sec_strength(drbg_flag_t flags)
     209                 :            : {
     210                 :          0 :         switch (flags & DRBG_STRENGTH_MASK) {
     211                 :            :         case DRBG_STRENGTH128:
     212                 :            :                 return 16;
     213                 :            :         case DRBG_STRENGTH192:
     214                 :            :                 return 24;
     215                 :            :         case DRBG_STRENGTH256:
     216                 :            :                 return 32;
     217                 :            :         default:
     218                 :            :                 return 32;
     219                 :            :         }
     220                 :            : }
     221                 :            : 
     222                 :            : /*
     223                 :            :  * FIPS 140-2 continuous self test for the noise source
     224                 :            :  * The test is performed on the noise source input data. Thus, the function
     225                 :            :  * implicitly knows the size of the buffer to be equal to the security
     226                 :            :  * strength.
     227                 :            :  *
     228                 :            :  * Note, this function disregards the nonce trailing the entropy data during
     229                 :            :  * initial seeding.
     230                 :            :  *
     231                 :            :  * drbg->drbg_mutex must have been taken.
     232                 :            :  *
     233                 :            :  * @drbg DRBG handle
     234                 :            :  * @entropy buffer of seed data to be checked
     235                 :            :  *
     236                 :            :  * return:
     237                 :            :  *      0 on success
     238                 :            :  *      -EAGAIN on when the CTRNG is not yet primed
     239                 :            :  *      < 0 on error
     240                 :            :  */
     241                 :          0 : static int drbg_fips_continuous_test(struct drbg_state *drbg,
     242                 :            :                                      const unsigned char *entropy)
     243                 :            : {
     244                 :          0 :         unsigned short entropylen = drbg_sec_strength(drbg->core->flags);
     245                 :          0 :         int ret = 0;
     246                 :            : 
     247                 :          0 :         if (!IS_ENABLED(CONFIG_CRYPTO_FIPS))
     248                 :          0 :                 return 0;
     249                 :            : 
     250                 :            :         /* skip test if we test the overall system */
     251                 :            :         if (list_empty(&drbg->test_data.list))
     252                 :            :                 return 0;
     253                 :            :         /* only perform test in FIPS mode */
     254                 :            :         if (!fips_enabled)
     255                 :            :                 return 0;
     256                 :            : 
     257                 :            :         if (!drbg->fips_primed) {
     258                 :            :                 /* Priming of FIPS test */
     259                 :            :                 memcpy(drbg->prev, entropy, entropylen);
     260                 :            :                 drbg->fips_primed = true;
     261                 :            :                 /* priming: another round is needed */
     262                 :            :                 return -EAGAIN;
     263                 :            :         }
     264                 :            :         ret = memcmp(drbg->prev, entropy, entropylen);
     265                 :            :         if (!ret)
     266                 :            :                 panic("DRBG continuous self test failed\n");
     267                 :            :         memcpy(drbg->prev, entropy, entropylen);
     268                 :            : 
     269                 :            :         /* the test shall pass when the two values are not equal */
     270                 :            :         return 0;
     271                 :            : }
     272                 :            : 
     273                 :            : /*
     274                 :            :  * Convert an integer into a byte representation of this integer.
     275                 :            :  * The byte representation is big-endian
     276                 :            :  *
     277                 :            :  * @val value to be converted
     278                 :            :  * @buf buffer holding the converted integer -- caller must ensure that
     279                 :            :  *      buffer size is at least 32 bit
     280                 :            :  */
     281                 :            : #if (defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_CTR))
     282                 :            : static inline void drbg_cpu_to_be32(__u32 val, unsigned char *buf)
     283                 :            : {
     284                 :            :         struct s {
     285                 :            :                 __be32 conv;
     286                 :            :         };
     287                 :            :         struct s *conversion = (struct s *) buf;
     288                 :            : 
     289                 :            :         conversion->conv = cpu_to_be32(val);
     290                 :            : }
     291                 :            : #endif /* defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_CTR) */
     292                 :            : 
     293                 :            : /******************************************************************
     294                 :            :  * CTR DRBG callback functions
     295                 :            :  ******************************************************************/
     296                 :            : 
     297                 :            : #ifdef CONFIG_CRYPTO_DRBG_CTR
     298                 :            : #define CRYPTO_DRBG_CTR_STRING "CTR "
     299                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes256");
     300                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes256");
     301                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes192");
     302                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes192");
     303                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes128");
     304                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes128");
     305                 :            : 
     306                 :            : static void drbg_kcapi_symsetkey(struct drbg_state *drbg,
     307                 :            :                                  const unsigned char *key);
     308                 :            : static int drbg_kcapi_sym(struct drbg_state *drbg, unsigned char *outval,
     309                 :            :                           const struct drbg_string *in);
     310                 :            : static int drbg_init_sym_kernel(struct drbg_state *drbg);
     311                 :            : static int drbg_fini_sym_kernel(struct drbg_state *drbg);
     312                 :            : static int drbg_kcapi_sym_ctr(struct drbg_state *drbg,
     313                 :            :                               u8 *inbuf, u32 inbuflen,
     314                 :            :                               u8 *outbuf, u32 outlen);
     315                 :            : #define DRBG_OUTSCRATCHLEN 256
     316                 :            : 
     317                 :            : /* BCC function for CTR DRBG as defined in 10.4.3 */
     318                 :            : static int drbg_ctr_bcc(struct drbg_state *drbg,
     319                 :            :                         unsigned char *out, const unsigned char *key,
     320                 :            :                         struct list_head *in)
     321                 :            : {
     322                 :            :         int ret = 0;
     323                 :            :         struct drbg_string *curr = NULL;
     324                 :            :         struct drbg_string data;
     325                 :            :         short cnt = 0;
     326                 :            : 
     327                 :            :         drbg_string_fill(&data, out, drbg_blocklen(drbg));
     328                 :            : 
     329                 :            :         /* 10.4.3 step 2 / 4 */
     330                 :            :         drbg_kcapi_symsetkey(drbg, key);
     331                 :            :         list_for_each_entry(curr, in, list) {
     332                 :            :                 const unsigned char *pos = curr->buf;
     333                 :            :                 size_t len = curr->len;
     334                 :            :                 /* 10.4.3 step 4.1 */
     335                 :            :                 while (len) {
     336                 :            :                         /* 10.4.3 step 4.2 */
     337                 :            :                         if (drbg_blocklen(drbg) == cnt) {
     338                 :            :                                 cnt = 0;
     339                 :            :                                 ret = drbg_kcapi_sym(drbg, out, &data);
     340                 :            :                                 if (ret)
     341                 :            :                                         return ret;
     342                 :            :                         }
     343                 :            :                         out[cnt] ^= *pos;
     344                 :            :                         pos++;
     345                 :            :                         cnt++;
     346                 :            :                         len--;
     347                 :            :                 }
     348                 :            :         }
     349                 :            :         /* 10.4.3 step 4.2 for last block */
     350                 :            :         if (cnt)
     351                 :            :                 ret = drbg_kcapi_sym(drbg, out, &data);
     352                 :            : 
     353                 :            :         return ret;
     354                 :            : }
     355                 :            : 
     356                 :            : /*
     357                 :            :  * scratchpad usage: drbg_ctr_update is interlinked with drbg_ctr_df
     358                 :            :  * (and drbg_ctr_bcc, but this function does not need any temporary buffers),
     359                 :            :  * the scratchpad is used as follows:
     360                 :            :  * drbg_ctr_update:
     361                 :            :  *      temp
     362                 :            :  *              start: drbg->scratchpad
     363                 :            :  *              length: drbg_statelen(drbg) + drbg_blocklen(drbg)
     364                 :            :  *                      note: the cipher writing into this variable works
     365                 :            :  *                      blocklen-wise. Now, when the statelen is not a multiple
     366                 :            :  *                      of blocklen, the generateion loop below "spills over"
     367                 :            :  *                      by at most blocklen. Thus, we need to give sufficient
     368                 :            :  *                      memory.
     369                 :            :  *      df_data
     370                 :            :  *              start: drbg->scratchpad +
     371                 :            :  *                              drbg_statelen(drbg) + drbg_blocklen(drbg)
     372                 :            :  *              length: drbg_statelen(drbg)
     373                 :            :  *
     374                 :            :  * drbg_ctr_df:
     375                 :            :  *      pad
     376                 :            :  *              start: df_data + drbg_statelen(drbg)
     377                 :            :  *              length: drbg_blocklen(drbg)
     378                 :            :  *      iv
     379                 :            :  *              start: pad + drbg_blocklen(drbg)
     380                 :            :  *              length: drbg_blocklen(drbg)
     381                 :            :  *      temp
     382                 :            :  *              start: iv + drbg_blocklen(drbg)
     383                 :            :  *              length: drbg_satelen(drbg) + drbg_blocklen(drbg)
     384                 :            :  *                      note: temp is the buffer that the BCC function operates
     385                 :            :  *                      on. BCC operates blockwise. drbg_statelen(drbg)
     386                 :            :  *                      is sufficient when the DRBG state length is a multiple
     387                 :            :  *                      of the block size. For AES192 (and maybe other ciphers)
     388                 :            :  *                      this is not correct and the length for temp is
     389                 :            :  *                      insufficient (yes, that also means for such ciphers,
     390                 :            :  *                      the final output of all BCC rounds are truncated).
     391                 :            :  *                      Therefore, add drbg_blocklen(drbg) to cover all
     392                 :            :  *                      possibilities.
     393                 :            :  */
     394                 :            : 
     395                 :            : /* Derivation Function for CTR DRBG as defined in 10.4.2 */
     396                 :            : static int drbg_ctr_df(struct drbg_state *drbg,
     397                 :            :                        unsigned char *df_data, size_t bytes_to_return,
     398                 :            :                        struct list_head *seedlist)
     399                 :            : {
     400                 :            :         int ret = -EFAULT;
     401                 :            :         unsigned char L_N[8];
     402                 :            :         /* S3 is input */
     403                 :            :         struct drbg_string S1, S2, S4, cipherin;
     404                 :            :         LIST_HEAD(bcc_list);
     405                 :            :         unsigned char *pad = df_data + drbg_statelen(drbg);
     406                 :            :         unsigned char *iv = pad + drbg_blocklen(drbg);
     407                 :            :         unsigned char *temp = iv + drbg_blocklen(drbg);
     408                 :            :         size_t padlen = 0;
     409                 :            :         unsigned int templen = 0;
     410                 :            :         /* 10.4.2 step 7 */
     411                 :            :         unsigned int i = 0;
     412                 :            :         /* 10.4.2 step 8 */
     413                 :            :         const unsigned char *K = (unsigned char *)
     414                 :            :                            "\x00\x01\x02\x03\x04\x05\x06\x07"
     415                 :            :                            "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
     416                 :            :                            "\x10\x11\x12\x13\x14\x15\x16\x17"
     417                 :            :                            "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f";
     418                 :            :         unsigned char *X;
     419                 :            :         size_t generated_len = 0;
     420                 :            :         size_t inputlen = 0;
     421                 :            :         struct drbg_string *seed = NULL;
     422                 :            : 
     423                 :            :         memset(pad, 0, drbg_blocklen(drbg));
     424                 :            :         memset(iv, 0, drbg_blocklen(drbg));
     425                 :            : 
     426                 :            :         /* 10.4.2 step 1 is implicit as we work byte-wise */
     427                 :            : 
     428                 :            :         /* 10.4.2 step 2 */
     429                 :            :         if ((512/8) < bytes_to_return)
     430                 :            :                 return -EINVAL;
     431                 :            : 
     432                 :            :         /* 10.4.2 step 2 -- calculate the entire length of all input data */
     433                 :            :         list_for_each_entry(seed, seedlist, list)
     434                 :            :                 inputlen += seed->len;
     435                 :            :         drbg_cpu_to_be32(inputlen, &L_N[0]);
     436                 :            : 
     437                 :            :         /* 10.4.2 step 3 */
     438                 :            :         drbg_cpu_to_be32(bytes_to_return, &L_N[4]);
     439                 :            : 
     440                 :            :         /* 10.4.2 step 5: length is L_N, input_string, one byte, padding */
     441                 :            :         padlen = (inputlen + sizeof(L_N) + 1) % (drbg_blocklen(drbg));
     442                 :            :         /* wrap the padlen appropriately */
     443                 :            :         if (padlen)
     444                 :            :                 padlen = drbg_blocklen(drbg) - padlen;
     445                 :            :         /*
     446                 :            :          * pad / padlen contains the 0x80 byte and the following zero bytes.
     447                 :            :          * As the calculated padlen value only covers the number of zero
     448                 :            :          * bytes, this value has to be incremented by one for the 0x80 byte.
     449                 :            :          */
     450                 :            :         padlen++;
     451                 :            :         pad[0] = 0x80;
     452                 :            : 
     453                 :            :         /* 10.4.2 step 4 -- first fill the linked list and then order it */
     454                 :            :         drbg_string_fill(&S1, iv, drbg_blocklen(drbg));
     455                 :            :         list_add_tail(&S1.list, &bcc_list);
     456                 :            :         drbg_string_fill(&S2, L_N, sizeof(L_N));
     457                 :            :         list_add_tail(&S2.list, &bcc_list);
     458                 :            :         list_splice_tail(seedlist, &bcc_list);
     459                 :            :         drbg_string_fill(&S4, pad, padlen);
     460                 :            :         list_add_tail(&S4.list, &bcc_list);
     461                 :            : 
     462                 :            :         /* 10.4.2 step 9 */
     463                 :            :         while (templen < (drbg_keylen(drbg) + (drbg_blocklen(drbg)))) {
     464                 :            :                 /*
     465                 :            :                  * 10.4.2 step 9.1 - the padding is implicit as the buffer
     466                 :            :                  * holds zeros after allocation -- even the increment of i
     467                 :            :                  * is irrelevant as the increment remains within length of i
     468                 :            :                  */
     469                 :            :                 drbg_cpu_to_be32(i, iv);
     470                 :            :                 /* 10.4.2 step 9.2 -- BCC and concatenation with temp */
     471                 :            :                 ret = drbg_ctr_bcc(drbg, temp + templen, K, &bcc_list);
     472                 :            :                 if (ret)
     473                 :            :                         goto out;
     474                 :            :                 /* 10.4.2 step 9.3 */
     475                 :            :                 i++;
     476                 :            :                 templen += drbg_blocklen(drbg);
     477                 :            :         }
     478                 :            : 
     479                 :            :         /* 10.4.2 step 11 */
     480                 :            :         X = temp + (drbg_keylen(drbg));
     481                 :            :         drbg_string_fill(&cipherin, X, drbg_blocklen(drbg));
     482                 :            : 
     483                 :            :         /* 10.4.2 step 12: overwriting of outval is implemented in next step */
     484                 :            : 
     485                 :            :         /* 10.4.2 step 13 */
     486                 :            :         drbg_kcapi_symsetkey(drbg, temp);
     487                 :            :         while (generated_len < bytes_to_return) {
     488                 :            :                 short blocklen = 0;
     489                 :            :                 /*
     490                 :            :                  * 10.4.2 step 13.1: the truncation of the key length is
     491                 :            :                  * implicit as the key is only drbg_blocklen in size based on
     492                 :            :                  * the implementation of the cipher function callback
     493                 :            :                  */
     494                 :            :                 ret = drbg_kcapi_sym(drbg, X, &cipherin);
     495                 :            :                 if (ret)
     496                 :            :                         goto out;
     497                 :            :                 blocklen = (drbg_blocklen(drbg) <
     498                 :            :                                 (bytes_to_return - generated_len)) ?
     499                 :            :                             drbg_blocklen(drbg) :
     500                 :            :                                 (bytes_to_return - generated_len);
     501                 :            :                 /* 10.4.2 step 13.2 and 14 */
     502                 :            :                 memcpy(df_data + generated_len, X, blocklen);
     503                 :            :                 generated_len += blocklen;
     504                 :            :         }
     505                 :            : 
     506                 :            :         ret = 0;
     507                 :            : 
     508                 :            : out:
     509                 :            :         memset(iv, 0, drbg_blocklen(drbg));
     510                 :            :         memset(temp, 0, drbg_statelen(drbg) + drbg_blocklen(drbg));
     511                 :            :         memset(pad, 0, drbg_blocklen(drbg));
     512                 :            :         return ret;
     513                 :            : }
     514                 :            : 
     515                 :            : /*
     516                 :            :  * update function of CTR DRBG as defined in 10.2.1.2
     517                 :            :  *
     518                 :            :  * The reseed variable has an enhanced meaning compared to the update
     519                 :            :  * functions of the other DRBGs as follows:
     520                 :            :  * 0 => initial seed from initialization
     521                 :            :  * 1 => reseed via drbg_seed
     522                 :            :  * 2 => first invocation from drbg_ctr_update when addtl is present. In
     523                 :            :  *      this case, the df_data scratchpad is not deleted so that it is
     524                 :            :  *      available for another calls to prevent calling the DF function
     525                 :            :  *      again.
     526                 :            :  * 3 => second invocation from drbg_ctr_update. When the update function
     527                 :            :  *      was called with addtl, the df_data memory already contains the
     528                 :            :  *      DFed addtl information and we do not need to call DF again.
     529                 :            :  */
     530                 :            : static int drbg_ctr_update(struct drbg_state *drbg, struct list_head *seed,
     531                 :            :                            int reseed)
     532                 :            : {
     533                 :            :         int ret = -EFAULT;
     534                 :            :         /* 10.2.1.2 step 1 */
     535                 :            :         unsigned char *temp = drbg->scratchpad;
     536                 :            :         unsigned char *df_data = drbg->scratchpad + drbg_statelen(drbg) +
     537                 :            :                                  drbg_blocklen(drbg);
     538                 :            : 
     539                 :            :         if (3 > reseed)
     540                 :            :                 memset(df_data, 0, drbg_statelen(drbg));
     541                 :            : 
     542                 :            :         if (!reseed) {
     543                 :            :                 /*
     544                 :            :                  * The DRBG uses the CTR mode of the underlying AES cipher. The
     545                 :            :                  * CTR mode increments the counter value after the AES operation
     546                 :            :                  * but SP800-90A requires that the counter is incremented before
     547                 :            :                  * the AES operation. Hence, we increment it at the time we set
     548                 :            :                  * it by one.
     549                 :            :                  */
     550                 :            :                 crypto_inc(drbg->V, drbg_blocklen(drbg));
     551                 :            : 
     552                 :            :                 ret = crypto_skcipher_setkey(drbg->ctr_handle, drbg->C,
     553                 :            :                                              drbg_keylen(drbg));
     554                 :            :                 if (ret)
     555                 :            :                         goto out;
     556                 :            :         }
     557                 :            : 
     558                 :            :         /* 10.2.1.3.2 step 2 and 10.2.1.4.2 step 2 */
     559                 :            :         if (seed) {
     560                 :            :                 ret = drbg_ctr_df(drbg, df_data, drbg_statelen(drbg), seed);
     561                 :            :                 if (ret)
     562                 :            :                         goto out;
     563                 :            :         }
     564                 :            : 
     565                 :            :         ret = drbg_kcapi_sym_ctr(drbg, df_data, drbg_statelen(drbg),
     566                 :            :                                  temp, drbg_statelen(drbg));
     567                 :            :         if (ret)
     568                 :            :                 return ret;
     569                 :            : 
     570                 :            :         /* 10.2.1.2 step 5 */
     571                 :            :         ret = crypto_skcipher_setkey(drbg->ctr_handle, temp,
     572                 :            :                                      drbg_keylen(drbg));
     573                 :            :         if (ret)
     574                 :            :                 goto out;
     575                 :            :         /* 10.2.1.2 step 6 */
     576                 :            :         memcpy(drbg->V, temp + drbg_keylen(drbg), drbg_blocklen(drbg));
     577                 :            :         /* See above: increment counter by one to compensate timing of CTR op */
     578                 :            :         crypto_inc(drbg->V, drbg_blocklen(drbg));
     579                 :            :         ret = 0;
     580                 :            : 
     581                 :            : out:
     582                 :            :         memset(temp, 0, drbg_statelen(drbg) + drbg_blocklen(drbg));
     583                 :            :         if (2 != reseed)
     584                 :            :                 memset(df_data, 0, drbg_statelen(drbg));
     585                 :            :         return ret;
     586                 :            : }
     587                 :            : 
     588                 :            : /*
     589                 :            :  * scratchpad use: drbg_ctr_update is called independently from
     590                 :            :  * drbg_ctr_extract_bytes. Therefore, the scratchpad is reused
     591                 :            :  */
     592                 :            : /* Generate function of CTR DRBG as defined in 10.2.1.5.2 */
     593                 :            : static int drbg_ctr_generate(struct drbg_state *drbg,
     594                 :            :                              unsigned char *buf, unsigned int buflen,
     595                 :            :                              struct list_head *addtl)
     596                 :            : {
     597                 :            :         int ret;
     598                 :            :         int len = min_t(int, buflen, INT_MAX);
     599                 :            : 
     600                 :            :         /* 10.2.1.5.2 step 2 */
     601                 :            :         if (addtl && !list_empty(addtl)) {
     602                 :            :                 ret = drbg_ctr_update(drbg, addtl, 2);
     603                 :            :                 if (ret)
     604                 :            :                         return 0;
     605                 :            :         }
     606                 :            : 
     607                 :            :         /* 10.2.1.5.2 step 4.1 */
     608                 :            :         ret = drbg_kcapi_sym_ctr(drbg, NULL, 0, buf, len);
     609                 :            :         if (ret)
     610                 :            :                 return ret;
     611                 :            : 
     612                 :            :         /* 10.2.1.5.2 step 6 */
     613                 :            :         ret = drbg_ctr_update(drbg, NULL, 3);
     614                 :            :         if (ret)
     615                 :            :                 len = ret;
     616                 :            : 
     617                 :            :         return len;
     618                 :            : }
     619                 :            : 
     620                 :            : static const struct drbg_state_ops drbg_ctr_ops = {
     621                 :            :         .update         = drbg_ctr_update,
     622                 :            :         .generate       = drbg_ctr_generate,
     623                 :            :         .crypto_init    = drbg_init_sym_kernel,
     624                 :            :         .crypto_fini    = drbg_fini_sym_kernel,
     625                 :            : };
     626                 :            : #endif /* CONFIG_CRYPTO_DRBG_CTR */
     627                 :            : 
     628                 :            : /******************************************************************
     629                 :            :  * HMAC DRBG callback functions
     630                 :            :  ******************************************************************/
     631                 :            : 
     632                 :            : #if defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_HMAC)
     633                 :            : static int drbg_kcapi_hash(struct drbg_state *drbg, unsigned char *outval,
     634                 :            :                            const struct list_head *in);
     635                 :            : static void drbg_kcapi_hmacsetkey(struct drbg_state *drbg,
     636                 :            :                                   const unsigned char *key);
     637                 :            : static int drbg_init_hash_kernel(struct drbg_state *drbg);
     638                 :            : static int drbg_fini_hash_kernel(struct drbg_state *drbg);
     639                 :            : #endif /* (CONFIG_CRYPTO_DRBG_HASH || CONFIG_CRYPTO_DRBG_HMAC) */
     640                 :            : 
     641                 :            : #ifdef CONFIG_CRYPTO_DRBG_HMAC
     642                 :            : #define CRYPTO_DRBG_HMAC_STRING "HMAC "
     643                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha512");
     644                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha512");
     645                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha384");
     646                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha384");
     647                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha256");
     648                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha256");
     649                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha1");
     650                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha1");
     651                 :            : 
     652                 :            : /* update function of HMAC DRBG as defined in 10.1.2.2 */
     653                 :          0 : static int drbg_hmac_update(struct drbg_state *drbg, struct list_head *seed,
     654                 :            :                             int reseed)
     655                 :            : {
     656                 :          0 :         int ret = -EFAULT;
     657                 :          0 :         int i = 0;
     658                 :          0 :         struct drbg_string seed1, seed2, vdata;
     659                 :          0 :         LIST_HEAD(seedlist);
     660                 :          0 :         LIST_HEAD(vdatalist);
     661                 :            : 
     662         [ #  # ]:          0 :         if (!reseed) {
     663                 :            :                 /* 10.1.2.3 step 2 -- memset(0) of C is implicit with kzalloc */
     664         [ #  # ]:          0 :                 memset(drbg->V, 1, drbg_statelen(drbg));
     665                 :          0 :                 drbg_kcapi_hmacsetkey(drbg, drbg->C);
     666                 :            :         }
     667                 :            : 
     668   [ #  #  #  # ]:          0 :         drbg_string_fill(&seed1, drbg->V, drbg_statelen(drbg));
     669         [ #  # ]:          0 :         list_add_tail(&seed1.list, &seedlist);
     670                 :            :         /* buffer of seed2 will be filled in for loop below with one byte */
     671                 :          0 :         drbg_string_fill(&seed2, NULL, 1);
     672                 :          0 :         list_add_tail(&seed2.list, &seedlist);
     673                 :            :         /* input data of seed is allowed to be NULL at this point */
     674         [ #  # ]:          0 :         if (seed)
     675         [ #  # ]:          0 :                 list_splice_tail(seed, &seedlist);
     676                 :            : 
     677         [ #  # ]:          0 :         drbg_string_fill(&vdata, drbg->V, drbg_statelen(drbg));
     678                 :          0 :         list_add_tail(&vdata.list, &vdatalist);
     679         [ #  # ]:          0 :         for (i = 2; 0 < i; i--) {
     680                 :            :                 /* first round uses 0x0, second 0x1 */
     681                 :          0 :                 unsigned char prefix = DRBG_PREFIX0;
     682         [ #  # ]:          0 :                 if (1 == i)
     683                 :          0 :                         prefix = DRBG_PREFIX1;
     684                 :            :                 /* 10.1.2.2 step 1 and 4 -- concatenation and HMAC for key */
     685                 :          0 :                 seed2.buf = &prefix;
     686                 :          0 :                 ret = drbg_kcapi_hash(drbg, drbg->C, &seedlist);
     687         [ #  # ]:          0 :                 if (ret)
     688                 :          0 :                         return ret;
     689                 :          0 :                 drbg_kcapi_hmacsetkey(drbg, drbg->C);
     690                 :            : 
     691                 :            :                 /* 10.1.2.2 step 2 and 5 -- HMAC for V */
     692                 :          0 :                 ret = drbg_kcapi_hash(drbg, drbg->V, &vdatalist);
     693         [ #  # ]:          0 :                 if (ret)
     694                 :          0 :                         return ret;
     695                 :            : 
     696                 :            :                 /* 10.1.2.2 step 3 */
     697         [ #  # ]:          0 :                 if (!seed)
     698                 :            :                         return ret;
     699                 :            :         }
     700                 :            : 
     701                 :            :         return 0;
     702                 :            : }
     703                 :            : 
     704                 :            : /* generate function of HMAC DRBG as defined in 10.1.2.5 */
     705                 :          0 : static int drbg_hmac_generate(struct drbg_state *drbg,
     706                 :            :                               unsigned char *buf,
     707                 :            :                               unsigned int buflen,
     708                 :            :                               struct list_head *addtl)
     709                 :            : {
     710                 :          0 :         int len = 0;
     711                 :          0 :         int ret = 0;
     712                 :          0 :         struct drbg_string data;
     713                 :          0 :         LIST_HEAD(datalist);
     714                 :            : 
     715                 :            :         /* 10.1.2.5 step 2 */
     716   [ #  #  #  # ]:          0 :         if (addtl && !list_empty(addtl)) {
     717                 :          0 :                 ret = drbg_hmac_update(drbg, addtl, 1);
     718         [ #  # ]:          0 :                 if (ret)
     719                 :            :                         return ret;
     720                 :            :         }
     721                 :            : 
     722         [ #  # ]:          0 :         drbg_string_fill(&data, drbg->V, drbg_statelen(drbg));
     723                 :          0 :         list_add_tail(&data.list, &datalist);
     724         [ #  # ]:          0 :         while (len < buflen) {
     725                 :          0 :                 unsigned int outlen = 0;
     726                 :            :                 /* 10.1.2.5 step 4.1 */
     727                 :          0 :                 ret = drbg_kcapi_hash(drbg, drbg->V, &datalist);
     728         [ #  # ]:          0 :                 if (ret)
     729                 :          0 :                         return ret;
     730         [ #  # ]:          0 :                 outlen = (drbg_blocklen(drbg) < (buflen - len)) ?
     731         [ #  # ]:          0 :                           drbg_blocklen(drbg) : (buflen - len);
     732                 :            : 
     733                 :            :                 /* 10.1.2.5 step 4.2 */
     734                 :          0 :                 memcpy(buf + len, drbg->V, outlen);
     735                 :          0 :                 len += outlen;
     736                 :            :         }
     737                 :            : 
     738                 :            :         /* 10.1.2.5 step 6 */
     739   [ #  #  #  # ]:          0 :         if (addtl && !list_empty(addtl))
     740                 :          0 :                 ret = drbg_hmac_update(drbg, addtl, 1);
     741                 :            :         else
     742                 :          0 :                 ret = drbg_hmac_update(drbg, NULL, 1);
     743         [ #  # ]:          0 :         if (ret)
     744                 :          0 :                 return ret;
     745                 :            : 
     746                 :            :         return len;
     747                 :            : }
     748                 :            : 
     749                 :            : static const struct drbg_state_ops drbg_hmac_ops = {
     750                 :            :         .update         = drbg_hmac_update,
     751                 :            :         .generate       = drbg_hmac_generate,
     752                 :            :         .crypto_init    = drbg_init_hash_kernel,
     753                 :            :         .crypto_fini    = drbg_fini_hash_kernel,
     754                 :            : };
     755                 :            : #endif /* CONFIG_CRYPTO_DRBG_HMAC */
     756                 :            : 
     757                 :            : /******************************************************************
     758                 :            :  * Hash DRBG callback functions
     759                 :            :  ******************************************************************/
     760                 :            : 
     761                 :            : #ifdef CONFIG_CRYPTO_DRBG_HASH
     762                 :            : #define CRYPTO_DRBG_HASH_STRING "HASH "
     763                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_sha512");
     764                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_sha512");
     765                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_sha384");
     766                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_sha384");
     767                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_sha256");
     768                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_sha256");
     769                 :            : MODULE_ALIAS_CRYPTO("drbg_pr_sha1");
     770                 :            : MODULE_ALIAS_CRYPTO("drbg_nopr_sha1");
     771                 :            : 
     772                 :            : /*
     773                 :            :  * Increment buffer
     774                 :            :  *
     775                 :            :  * @dst buffer to increment
     776                 :            :  * @add value to add
     777                 :            :  */
     778                 :            : static inline void drbg_add_buf(unsigned char *dst, size_t dstlen,
     779                 :            :                                 const unsigned char *add, size_t addlen)
     780                 :            : {
     781                 :            :         /* implied: dstlen > addlen */
     782                 :            :         unsigned char *dstptr;
     783                 :            :         const unsigned char *addptr;
     784                 :            :         unsigned int remainder = 0;
     785                 :            :         size_t len = addlen;
     786                 :            : 
     787                 :            :         dstptr = dst + (dstlen-1);
     788                 :            :         addptr = add + (addlen-1);
     789                 :            :         while (len) {
     790                 :            :                 remainder += *dstptr + *addptr;
     791                 :            :                 *dstptr = remainder & 0xff;
     792                 :            :                 remainder >>= 8;
     793                 :            :                 len--; dstptr--; addptr--;
     794                 :            :         }
     795                 :            :         len = dstlen - addlen;
     796                 :            :         while (len && remainder > 0) {
     797                 :            :                 remainder = *dstptr + 1;
     798                 :            :                 *dstptr = remainder & 0xff;
     799                 :            :                 remainder >>= 8;
     800                 :            :                 len--; dstptr--;
     801                 :            :         }
     802                 :            : }
     803                 :            : 
     804                 :            : /*
     805                 :            :  * scratchpad usage: as drbg_hash_update and drbg_hash_df are used
     806                 :            :  * interlinked, the scratchpad is used as follows:
     807                 :            :  * drbg_hash_update
     808                 :            :  *      start: drbg->scratchpad
     809                 :            :  *      length: drbg_statelen(drbg)
     810                 :            :  * drbg_hash_df:
     811                 :            :  *      start: drbg->scratchpad + drbg_statelen(drbg)
     812                 :            :  *      length: drbg_blocklen(drbg)
     813                 :            :  *
     814                 :            :  * drbg_hash_process_addtl uses the scratchpad, but fully completes
     815                 :            :  * before either of the functions mentioned before are invoked. Therefore,
     816                 :            :  * drbg_hash_process_addtl does not need to be specifically considered.
     817                 :            :  */
     818                 :            : 
     819                 :            : /* Derivation Function for Hash DRBG as defined in 10.4.1 */
     820                 :            : static int drbg_hash_df(struct drbg_state *drbg,
     821                 :            :                         unsigned char *outval, size_t outlen,
     822                 :            :                         struct list_head *entropylist)
     823                 :            : {
     824                 :            :         int ret = 0;
     825                 :            :         size_t len = 0;
     826                 :            :         unsigned char input[5];
     827                 :            :         unsigned char *tmp = drbg->scratchpad + drbg_statelen(drbg);
     828                 :            :         struct drbg_string data;
     829                 :            : 
     830                 :            :         /* 10.4.1 step 3 */
     831                 :            :         input[0] = 1;
     832                 :            :         drbg_cpu_to_be32((outlen * 8), &input[1]);
     833                 :            : 
     834                 :            :         /* 10.4.1 step 4.1 -- concatenation of data for input into hash */
     835                 :            :         drbg_string_fill(&data, input, 5);
     836                 :            :         list_add(&data.list, entropylist);
     837                 :            : 
     838                 :            :         /* 10.4.1 step 4 */
     839                 :            :         while (len < outlen) {
     840                 :            :                 short blocklen = 0;
     841                 :            :                 /* 10.4.1 step 4.1 */
     842                 :            :                 ret = drbg_kcapi_hash(drbg, tmp, entropylist);
     843                 :            :                 if (ret)
     844                 :            :                         goto out;
     845                 :            :                 /* 10.4.1 step 4.2 */
     846                 :            :                 input[0]++;
     847                 :            :                 blocklen = (drbg_blocklen(drbg) < (outlen - len)) ?
     848                 :            :                             drbg_blocklen(drbg) : (outlen - len);
     849                 :            :                 memcpy(outval + len, tmp, blocklen);
     850                 :            :                 len += blocklen;
     851                 :            :         }
     852                 :            : 
     853                 :            : out:
     854                 :            :         memset(tmp, 0, drbg_blocklen(drbg));
     855                 :            :         return ret;
     856                 :            : }
     857                 :            : 
     858                 :            : /* update function for Hash DRBG as defined in 10.1.1.2 / 10.1.1.3 */
     859                 :            : static int drbg_hash_update(struct drbg_state *drbg, struct list_head *seed,
     860                 :            :                             int reseed)
     861                 :            : {
     862                 :            :         int ret = 0;
     863                 :            :         struct drbg_string data1, data2;
     864                 :            :         LIST_HEAD(datalist);
     865                 :            :         LIST_HEAD(datalist2);
     866                 :            :         unsigned char *V = drbg->scratchpad;
     867                 :            :         unsigned char prefix = DRBG_PREFIX1;
     868                 :            : 
     869                 :            :         if (!seed)
     870                 :            :                 return -EINVAL;
     871                 :            : 
     872                 :            :         if (reseed) {
     873                 :            :                 /* 10.1.1.3 step 1 */
     874                 :            :                 memcpy(V, drbg->V, drbg_statelen(drbg));
     875                 :            :                 drbg_string_fill(&data1, &prefix, 1);
     876                 :            :                 list_add_tail(&data1.list, &datalist);
     877                 :            :                 drbg_string_fill(&data2, V, drbg_statelen(drbg));
     878                 :            :                 list_add_tail(&data2.list, &datalist);
     879                 :            :         }
     880                 :            :         list_splice_tail(seed, &datalist);
     881                 :            : 
     882                 :            :         /* 10.1.1.2 / 10.1.1.3 step 2 and 3 */
     883                 :            :         ret = drbg_hash_df(drbg, drbg->V, drbg_statelen(drbg), &datalist);
     884                 :            :         if (ret)
     885                 :            :                 goto out;
     886                 :            : 
     887                 :            :         /* 10.1.1.2 / 10.1.1.3 step 4  */
     888                 :            :         prefix = DRBG_PREFIX0;
     889                 :            :         drbg_string_fill(&data1, &prefix, 1);
     890                 :            :         list_add_tail(&data1.list, &datalist2);
     891                 :            :         drbg_string_fill(&data2, drbg->V, drbg_statelen(drbg));
     892                 :            :         list_add_tail(&data2.list, &datalist2);
     893                 :            :         /* 10.1.1.2 / 10.1.1.3 step 4 */
     894                 :            :         ret = drbg_hash_df(drbg, drbg->C, drbg_statelen(drbg), &datalist2);
     895                 :            : 
     896                 :            : out:
     897                 :            :         memset(drbg->scratchpad, 0, drbg_statelen(drbg));
     898                 :            :         return ret;
     899                 :            : }
     900                 :            : 
     901                 :            : /* processing of additional information string for Hash DRBG */
     902                 :            : static int drbg_hash_process_addtl(struct drbg_state *drbg,
     903                 :            :                                    struct list_head *addtl)
     904                 :            : {
     905                 :            :         int ret = 0;
     906                 :            :         struct drbg_string data1, data2;
     907                 :            :         LIST_HEAD(datalist);
     908                 :            :         unsigned char prefix = DRBG_PREFIX2;
     909                 :            : 
     910                 :            :         /* 10.1.1.4 step 2 */
     911                 :            :         if (!addtl || list_empty(addtl))
     912                 :            :                 return 0;
     913                 :            : 
     914                 :            :         /* 10.1.1.4 step 2a */
     915                 :            :         drbg_string_fill(&data1, &prefix, 1);
     916                 :            :         drbg_string_fill(&data2, drbg->V, drbg_statelen(drbg));
     917                 :            :         list_add_tail(&data1.list, &datalist);
     918                 :            :         list_add_tail(&data2.list, &datalist);
     919                 :            :         list_splice_tail(addtl, &datalist);
     920                 :            :         ret = drbg_kcapi_hash(drbg, drbg->scratchpad, &datalist);
     921                 :            :         if (ret)
     922                 :            :                 goto out;
     923                 :            : 
     924                 :            :         /* 10.1.1.4 step 2b */
     925                 :            :         drbg_add_buf(drbg->V, drbg_statelen(drbg),
     926                 :            :                      drbg->scratchpad, drbg_blocklen(drbg));
     927                 :            : 
     928                 :            : out:
     929                 :            :         memset(drbg->scratchpad, 0, drbg_blocklen(drbg));
     930                 :            :         return ret;
     931                 :            : }
     932                 :            : 
     933                 :            : /* Hashgen defined in 10.1.1.4 */
     934                 :            : static int drbg_hash_hashgen(struct drbg_state *drbg,
     935                 :            :                              unsigned char *buf,
     936                 :            :                              unsigned int buflen)
     937                 :            : {
     938                 :            :         int len = 0;
     939                 :            :         int ret = 0;
     940                 :            :         unsigned char *src = drbg->scratchpad;
     941                 :            :         unsigned char *dst = drbg->scratchpad + drbg_statelen(drbg);
     942                 :            :         struct drbg_string data;
     943                 :            :         LIST_HEAD(datalist);
     944                 :            : 
     945                 :            :         /* 10.1.1.4 step hashgen 2 */
     946                 :            :         memcpy(src, drbg->V, drbg_statelen(drbg));
     947                 :            : 
     948                 :            :         drbg_string_fill(&data, src, drbg_statelen(drbg));
     949                 :            :         list_add_tail(&data.list, &datalist);
     950                 :            :         while (len < buflen) {
     951                 :            :                 unsigned int outlen = 0;
     952                 :            :                 /* 10.1.1.4 step hashgen 4.1 */
     953                 :            :                 ret = drbg_kcapi_hash(drbg, dst, &datalist);
     954                 :            :                 if (ret) {
     955                 :            :                         len = ret;
     956                 :            :                         goto out;
     957                 :            :                 }
     958                 :            :                 outlen = (drbg_blocklen(drbg) < (buflen - len)) ?
     959                 :            :                           drbg_blocklen(drbg) : (buflen - len);
     960                 :            :                 /* 10.1.1.4 step hashgen 4.2 */
     961                 :            :                 memcpy(buf + len, dst, outlen);
     962                 :            :                 len += outlen;
     963                 :            :                 /* 10.1.1.4 hashgen step 4.3 */
     964                 :            :                 if (len < buflen)
     965                 :            :                         crypto_inc(src, drbg_statelen(drbg));
     966                 :            :         }
     967                 :            : 
     968                 :            : out:
     969                 :            :         memset(drbg->scratchpad, 0,
     970                 :            :                (drbg_statelen(drbg) + drbg_blocklen(drbg)));
     971                 :            :         return len;
     972                 :            : }
     973                 :            : 
     974                 :            : /* generate function for Hash DRBG as defined in  10.1.1.4 */
     975                 :            : static int drbg_hash_generate(struct drbg_state *drbg,
     976                 :            :                               unsigned char *buf, unsigned int buflen,
     977                 :            :                               struct list_head *addtl)
     978                 :            : {
     979                 :            :         int len = 0;
     980                 :            :         int ret = 0;
     981                 :            :         union {
     982                 :            :                 unsigned char req[8];
     983                 :            :                 __be64 req_int;
     984                 :            :         } u;
     985                 :            :         unsigned char prefix = DRBG_PREFIX3;
     986                 :            :         struct drbg_string data1, data2;
     987                 :            :         LIST_HEAD(datalist);
     988                 :            : 
     989                 :            :         /* 10.1.1.4 step 2 */
     990                 :            :         ret = drbg_hash_process_addtl(drbg, addtl);
     991                 :            :         if (ret)
     992                 :            :                 return ret;
     993                 :            :         /* 10.1.1.4 step 3 */
     994                 :            :         len = drbg_hash_hashgen(drbg, buf, buflen);
     995                 :            : 
     996                 :            :         /* this is the value H as documented in 10.1.1.4 */
     997                 :            :         /* 10.1.1.4 step 4 */
     998                 :            :         drbg_string_fill(&data1, &prefix, 1);
     999                 :            :         list_add_tail(&data1.list, &datalist);
    1000                 :            :         drbg_string_fill(&data2, drbg->V, drbg_statelen(drbg));
    1001                 :            :         list_add_tail(&data2.list, &datalist);
    1002                 :            :         ret = drbg_kcapi_hash(drbg, drbg->scratchpad, &datalist);
    1003                 :            :         if (ret) {
    1004                 :            :                 len = ret;
    1005                 :            :                 goto out;
    1006                 :            :         }
    1007                 :            : 
    1008                 :            :         /* 10.1.1.4 step 5 */
    1009                 :            :         drbg_add_buf(drbg->V, drbg_statelen(drbg),
    1010                 :            :                      drbg->scratchpad, drbg_blocklen(drbg));
    1011                 :            :         drbg_add_buf(drbg->V, drbg_statelen(drbg),
    1012                 :            :                      drbg->C, drbg_statelen(drbg));
    1013                 :            :         u.req_int = cpu_to_be64(drbg->reseed_ctr);
    1014                 :            :         drbg_add_buf(drbg->V, drbg_statelen(drbg), u.req, 8);
    1015                 :            : 
    1016                 :            : out:
    1017                 :            :         memset(drbg->scratchpad, 0, drbg_blocklen(drbg));
    1018                 :            :         return len;
    1019                 :            : }
    1020                 :            : 
    1021                 :            : /*
    1022                 :            :  * scratchpad usage: as update and generate are used isolated, both
    1023                 :            :  * can use the scratchpad
    1024                 :            :  */
    1025                 :            : static const struct drbg_state_ops drbg_hash_ops = {
    1026                 :            :         .update         = drbg_hash_update,
    1027                 :            :         .generate       = drbg_hash_generate,
    1028                 :            :         .crypto_init    = drbg_init_hash_kernel,
    1029                 :            :         .crypto_fini    = drbg_fini_hash_kernel,
    1030                 :            : };
    1031                 :            : #endif /* CONFIG_CRYPTO_DRBG_HASH */
    1032                 :            : 
    1033                 :            : /******************************************************************
    1034                 :            :  * Functions common for DRBG implementations
    1035                 :            :  ******************************************************************/
    1036                 :            : 
    1037                 :          0 : static inline int __drbg_seed(struct drbg_state *drbg, struct list_head *seed,
    1038                 :            :                               int reseed)
    1039                 :            : {
    1040                 :          0 :         int ret = drbg->d_ops->update(drbg, seed, reseed);
    1041                 :            : 
    1042   [ #  #  #  # ]:          0 :         if (ret)
    1043                 :            :                 return ret;
    1044                 :            : 
    1045                 :          0 :         drbg->seeded = true;
    1046                 :            :         /* 10.1.1.2 / 10.1.1.3 step 5 */
    1047                 :          0 :         drbg->reseed_ctr = 1;
    1048                 :            : 
    1049                 :          0 :         return ret;
    1050                 :            : }
    1051                 :            : 
    1052                 :          0 : static inline int drbg_get_random_bytes(struct drbg_state *drbg,
    1053                 :            :                                         unsigned char *entropy,
    1054                 :            :                                         unsigned int entropylen)
    1055                 :            : {
    1056                 :          0 :         int ret;
    1057                 :            : 
    1058                 :          0 :         do {
    1059                 :          0 :                 get_random_bytes(entropy, entropylen);
    1060                 :          0 :                 ret = drbg_fips_continuous_test(drbg, entropy);
    1061                 :          0 :                 if (ret && ret != -EAGAIN)
    1062                 :            :                         return ret;
    1063                 :          0 :         } while (ret);
    1064                 :            : 
    1065                 :          0 :         return 0;
    1066                 :            : }
    1067                 :            : 
    1068                 :          0 : static void drbg_async_seed(struct work_struct *work)
    1069                 :            : {
    1070                 :          0 :         struct drbg_string data;
    1071                 :          0 :         LIST_HEAD(seedlist);
    1072                 :          0 :         struct drbg_state *drbg = container_of(work, struct drbg_state,
    1073                 :            :                                                seed_work);
    1074         [ #  # ]:          0 :         unsigned int entropylen = drbg_sec_strength(drbg->core->flags);
    1075                 :          0 :         unsigned char entropy[32];
    1076                 :          0 :         int ret;
    1077                 :            : 
    1078                 :          0 :         BUG_ON(!entropylen);
    1079                 :          0 :         BUG_ON(entropylen > sizeof(entropy));
    1080                 :            : 
    1081                 :          0 :         drbg_string_fill(&data, entropy, entropylen);
    1082                 :          0 :         list_add_tail(&data.list, &seedlist);
    1083                 :            : 
    1084                 :          0 :         mutex_lock(&drbg->drbg_mutex);
    1085                 :            : 
    1086                 :          0 :         ret = drbg_get_random_bytes(drbg, entropy, entropylen);
    1087                 :          0 :         if (ret)
    1088                 :            :                 goto unlock;
    1089                 :            : 
    1090                 :            :         /* If nonblocking pool is initialized, deactivate Jitter RNG */
    1091                 :          0 :         crypto_free_rng(drbg->jent);
    1092                 :          0 :         drbg->jent = NULL;
    1093                 :            : 
    1094                 :            :         /* Set seeded to false so that if __drbg_seed fails the
    1095                 :            :          * next generate call will trigger a reseed.
    1096                 :            :          */
    1097                 :          0 :         drbg->seeded = false;
    1098                 :            : 
    1099                 :          0 :         __drbg_seed(drbg, &seedlist, true);
    1100                 :            : 
    1101         [ #  # ]:          0 :         if (drbg->seeded)
    1102                 :          0 :                 drbg->reseed_threshold = drbg_max_requests(drbg);
    1103                 :            : 
    1104                 :          0 : unlock:
    1105                 :          0 :         mutex_unlock(&drbg->drbg_mutex);
    1106                 :            : 
    1107                 :          0 :         memzero_explicit(entropy, entropylen);
    1108                 :          0 : }
    1109                 :            : 
    1110                 :            : /*
    1111                 :            :  * Seeding or reseeding of the DRBG
    1112                 :            :  *
    1113                 :            :  * @drbg: DRBG state struct
    1114                 :            :  * @pers: personalization / additional information buffer
    1115                 :            :  * @reseed: 0 for initial seed process, 1 for reseeding
    1116                 :            :  *
    1117                 :            :  * return:
    1118                 :            :  *      0 on success
    1119                 :            :  *      error value otherwise
    1120                 :            :  */
    1121                 :          0 : static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,
    1122                 :            :                      bool reseed)
    1123                 :            : {
    1124                 :          0 :         int ret;
    1125                 :          0 :         unsigned char entropy[((32 + 16) * 2)];
    1126         [ #  # ]:          0 :         unsigned int entropylen = drbg_sec_strength(drbg->core->flags);
    1127                 :          0 :         struct drbg_string data1;
    1128                 :          0 :         LIST_HEAD(seedlist);
    1129                 :            : 
    1130                 :            :         /* 9.1 / 9.2 / 9.3.1 step 3 */
    1131   [ #  #  #  # ]:          0 :         if (pers && pers->len > (drbg_max_addtl(drbg))) {
    1132                 :            :                 pr_devel("DRBG: personalization string too long %zu\n",
    1133                 :            :                          pers->len);
    1134                 :            :                 return -EINVAL;
    1135                 :            :         }
    1136                 :            : 
    1137         [ #  # ]:          0 :         if (list_empty(&drbg->test_data.list)) {
    1138                 :          0 :                 drbg_string_fill(&data1, drbg->test_data.buf,
    1139                 :            :                                  drbg->test_data.len);
    1140                 :          0 :                 pr_devel("DRBG: using test entropy\n");
    1141                 :            :         } else {
    1142                 :            :                 /*
    1143                 :            :                  * Gather entropy equal to the security strength of the DRBG.
    1144                 :            :                  * With a derivation function, a nonce is required in addition
    1145                 :            :                  * to the entropy. A nonce must be at least 1/2 of the security
    1146                 :            :                  * strength of the DRBG in size. Thus, entropy + nonce is 3/2
    1147                 :            :                  * of the strength. The consideration of a nonce is only
    1148                 :            :                  * applicable during initial seeding.
    1149                 :            :                  */
    1150                 :          0 :                 BUG_ON(!entropylen);
    1151         [ #  # ]:          0 :                 if (!reseed)
    1152                 :          0 :                         entropylen = ((entropylen + 1) / 2) * 3;
    1153                 :          0 :                 BUG_ON((entropylen * 2) > sizeof(entropy));
    1154                 :            : 
    1155                 :            :                 /* Get seed from in-kernel /dev/urandom */
    1156                 :          0 :                 ret = drbg_get_random_bytes(drbg, entropy, entropylen);
    1157                 :          0 :                 if (ret)
    1158                 :            :                         goto out;
    1159                 :            : 
    1160         [ #  # ]:          0 :                 if (!drbg->jent) {
    1161                 :          0 :                         drbg_string_fill(&data1, entropy, entropylen);
    1162                 :          0 :                         pr_devel("DRBG: (re)seeding with %u bytes of entropy\n",
    1163                 :            :                                  entropylen);
    1164                 :            :                 } else {
    1165                 :            :                         /* Get seed from Jitter RNG */
    1166                 :          0 :                         ret = crypto_rng_get_bytes(drbg->jent,
    1167                 :            :                                                    entropy + entropylen,
    1168                 :            :                                                    entropylen);
    1169         [ #  # ]:          0 :                         if (ret) {
    1170                 :          0 :                                 pr_devel("DRBG: jent failed with %d\n", ret);
    1171                 :          0 :                                 goto out;
    1172                 :            :                         }
    1173                 :            : 
    1174                 :          0 :                         drbg_string_fill(&data1, entropy, entropylen * 2);
    1175                 :          0 :                         pr_devel("DRBG: (re)seeding with %u bytes of entropy\n",
    1176                 :            :                                  entropylen * 2);
    1177                 :            :                 }
    1178                 :            :         }
    1179         [ #  # ]:          0 :         list_add_tail(&data1.list, &seedlist);
    1180                 :            : 
    1181                 :            :         /*
    1182                 :            :          * concatenation of entropy with personalization str / addtl input)
    1183                 :            :          * the variable pers is directly handed in by the caller, so check its
    1184                 :            :          * contents whether it is appropriate
    1185                 :            :          */
    1186   [ #  #  #  #  :          0 :         if (pers && pers->buf && 0 < pers->len) {
                   #  # ]
    1187                 :          0 :                 list_add_tail(&pers->list, &seedlist);
    1188                 :          0 :                 pr_devel("DRBG: using personalization string\n");
    1189                 :            :         }
    1190                 :            : 
    1191         [ #  # ]:          0 :         if (!reseed) {
    1192         [ #  # ]:          0 :                 memset(drbg->V, 0, drbg_statelen(drbg));
    1193         [ #  # ]:          0 :                 memset(drbg->C, 0, drbg_statelen(drbg));
    1194                 :            :         }
    1195                 :            : 
    1196                 :          0 :         ret = __drbg_seed(drbg, &seedlist, reseed);
    1197                 :            : 
    1198                 :          0 : out:
    1199                 :          0 :         memzero_explicit(entropy, entropylen * 2);
    1200                 :            : 
    1201                 :          0 :         return ret;
    1202                 :            : }
    1203                 :            : 
    1204                 :            : /* Free all substructures in a DRBG state without the DRBG state structure */
    1205                 :          0 : static inline void drbg_dealloc_state(struct drbg_state *drbg)
    1206                 :            : {
    1207         [ #  # ]:          0 :         if (!drbg)
    1208                 :            :                 return;
    1209                 :          0 :         kzfree(drbg->Vbuf);
    1210                 :          0 :         drbg->Vbuf = NULL;
    1211                 :          0 :         drbg->V = NULL;
    1212                 :          0 :         kzfree(drbg->Cbuf);
    1213                 :          0 :         drbg->Cbuf = NULL;
    1214                 :          0 :         drbg->C = NULL;
    1215                 :          0 :         kzfree(drbg->scratchpadbuf);
    1216                 :          0 :         drbg->scratchpadbuf = NULL;
    1217                 :          0 :         drbg->reseed_ctr = 0;
    1218                 :          0 :         drbg->d_ops = NULL;
    1219                 :          0 :         drbg->core = NULL;
    1220                 :          0 :         if (IS_ENABLED(CONFIG_CRYPTO_FIPS)) {
    1221                 :            :                 kzfree(drbg->prev);
    1222                 :            :                 drbg->prev = NULL;
    1223                 :            :                 drbg->fips_primed = false;
    1224                 :            :         }
    1225                 :            : }
    1226                 :            : 
    1227                 :            : /*
    1228                 :            :  * Allocate all sub-structures for a DRBG state.
    1229                 :            :  * The DRBG state structure must already be allocated.
    1230                 :            :  */
    1231                 :          0 : static inline int drbg_alloc_state(struct drbg_state *drbg)
    1232                 :            : {
    1233                 :          0 :         int ret = -ENOMEM;
    1234                 :          0 :         unsigned int sb_size = 0;
    1235                 :            : 
    1236         [ #  # ]:          0 :         switch (drbg->core->flags & DRBG_TYPE_MASK) {
    1237                 :            : #ifdef CONFIG_CRYPTO_DRBG_HMAC
    1238                 :          0 :         case DRBG_HMAC:
    1239                 :          0 :                 drbg->d_ops = &drbg_hmac_ops;
    1240                 :          0 :                 break;
    1241                 :            : #endif /* CONFIG_CRYPTO_DRBG_HMAC */
    1242                 :            : #ifdef CONFIG_CRYPTO_DRBG_HASH
    1243                 :            :         case DRBG_HASH:
    1244                 :            :                 drbg->d_ops = &drbg_hash_ops;
    1245                 :            :                 break;
    1246                 :            : #endif /* CONFIG_CRYPTO_DRBG_HASH */
    1247                 :            : #ifdef CONFIG_CRYPTO_DRBG_CTR
    1248                 :            :         case DRBG_CTR:
    1249                 :            :                 drbg->d_ops = &drbg_ctr_ops;
    1250                 :            :                 break;
    1251                 :            : #endif /* CONFIG_CRYPTO_DRBG_CTR */
    1252                 :          0 :         default:
    1253                 :          0 :                 ret = -EOPNOTSUPP;
    1254                 :          0 :                 goto err;
    1255                 :            :         }
    1256                 :            : 
    1257                 :          0 :         ret = drbg->d_ops->crypto_init(drbg);
    1258         [ #  # ]:          0 :         if (ret < 0)
    1259                 :          0 :                 goto err;
    1260                 :            : 
    1261   [ #  #  #  # ]:          0 :         drbg->Vbuf = kmalloc(drbg_statelen(drbg) + ret, GFP_KERNEL);
    1262         [ #  # ]:          0 :         if (!drbg->Vbuf) {
    1263                 :          0 :                 ret = -ENOMEM;
    1264                 :          0 :                 goto fini;
    1265                 :            :         }
    1266                 :          0 :         drbg->V = PTR_ALIGN(drbg->Vbuf, ret + 1);
    1267   [ #  #  #  # ]:          0 :         drbg->Cbuf = kmalloc(drbg_statelen(drbg) + ret, GFP_KERNEL);
    1268         [ #  # ]:          0 :         if (!drbg->Cbuf) {
    1269                 :          0 :                 ret = -ENOMEM;
    1270                 :          0 :                 goto fini;
    1271                 :            :         }
    1272                 :          0 :         drbg->C = PTR_ALIGN(drbg->Cbuf, ret + 1);
    1273                 :            :         /* scratchpad is only generated for CTR and Hash */
    1274         [ #  # ]:          0 :         if (drbg->core->flags & DRBG_HMAC)
    1275                 :            :                 sb_size = 0;
    1276         [ #  # ]:          0 :         else if (drbg->core->flags & DRBG_CTR)
    1277   [ #  #  #  #  :          0 :                 sb_size = drbg_statelen(drbg) + drbg_blocklen(drbg) + /* temp */
                   #  # ]
    1278         [ #  # ]:          0 :                           drbg_statelen(drbg) + /* df_data */
    1279         [ #  # ]:          0 :                           drbg_blocklen(drbg) + /* pad */
    1280         [ #  # ]:          0 :                           drbg_blocklen(drbg) + /* iv */
    1281         [ #  # ]:          0 :                           drbg_statelen(drbg) + drbg_blocklen(drbg); /* temp */
    1282                 :            :         else
    1283   [ #  #  #  # ]:          0 :                 sb_size = drbg_statelen(drbg) + drbg_blocklen(drbg);
    1284                 :            : 
    1285         [ #  # ]:          0 :         if (0 < sb_size) {
    1286                 :          0 :                 drbg->scratchpadbuf = kzalloc(sb_size + ret, GFP_KERNEL);
    1287         [ #  # ]:          0 :                 if (!drbg->scratchpadbuf) {
    1288                 :          0 :                         ret = -ENOMEM;
    1289                 :          0 :                         goto fini;
    1290                 :            :                 }
    1291                 :          0 :                 drbg->scratchpad = PTR_ALIGN(drbg->scratchpadbuf, ret + 1);
    1292                 :            :         }
    1293                 :            : 
    1294                 :            :         if (IS_ENABLED(CONFIG_CRYPTO_FIPS)) {
    1295                 :            :                 drbg->prev = kzalloc(drbg_sec_strength(drbg->core->flags),
    1296                 :            :                                      GFP_KERNEL);
    1297                 :            :                 if (!drbg->prev)
    1298                 :            :                         goto fini;
    1299                 :            :                 drbg->fips_primed = false;
    1300                 :            :         }
    1301                 :            : 
    1302                 :            :         return 0;
    1303                 :            : 
    1304                 :          0 : fini:
    1305                 :          0 :         drbg->d_ops->crypto_fini(drbg);
    1306                 :          0 : err:
    1307                 :          0 :         drbg_dealloc_state(drbg);
    1308                 :          0 :         return ret;
    1309                 :            : }
    1310                 :            : 
    1311                 :            : /*************************************************************************
    1312                 :            :  * DRBG interface functions
    1313                 :            :  *************************************************************************/
    1314                 :            : 
    1315                 :            : /*
    1316                 :            :  * DRBG generate function as required by SP800-90A - this function
    1317                 :            :  * generates random numbers
    1318                 :            :  *
    1319                 :            :  * @drbg DRBG state handle
    1320                 :            :  * @buf Buffer where to store the random numbers -- the buffer must already
    1321                 :            :  *      be pre-allocated by caller
    1322                 :            :  * @buflen Length of output buffer - this value defines the number of random
    1323                 :            :  *         bytes pulled from DRBG
    1324                 :            :  * @addtl Additional input that is mixed into state, may be NULL -- note
    1325                 :            :  *        the entropy is pulled by the DRBG internally unconditionally
    1326                 :            :  *        as defined in SP800-90A. The additional input is mixed into
    1327                 :            :  *        the state in addition to the pulled entropy.
    1328                 :            :  *
    1329                 :            :  * return: 0 when all bytes are generated; < 0 in case of an error
    1330                 :            :  */
    1331                 :          0 : static int drbg_generate(struct drbg_state *drbg,
    1332                 :            :                          unsigned char *buf, unsigned int buflen,
    1333                 :            :                          struct drbg_string *addtl)
    1334                 :            : {
    1335                 :          0 :         int len = 0;
    1336                 :          0 :         LIST_HEAD(addtllist);
    1337                 :            : 
    1338         [ #  # ]:          0 :         if (!drbg->core) {
    1339                 :            :                 pr_devel("DRBG: not yet seeded\n");
    1340                 :            :                 return -EINVAL;
    1341                 :            :         }
    1342         [ #  # ]:          0 :         if (0 == buflen || !buf) {
    1343                 :            :                 pr_devel("DRBG: no output buffer provided\n");
    1344                 :            :                 return -EINVAL;
    1345                 :            :         }
    1346   [ #  #  #  #  :          0 :         if (addtl && NULL == addtl->buf && 0 < addtl->len) {
                   #  # ]
    1347                 :            :                 pr_devel("DRBG: wrong format of additional information\n");
    1348                 :            :                 return -EINVAL;
    1349                 :            :         }
    1350                 :            : 
    1351                 :            :         /* 9.3.1 step 2 */
    1352                 :          0 :         len = -EINVAL;
    1353         [ #  # ]:          0 :         if (buflen > (drbg_max_request_bytes(drbg))) {
    1354                 :          0 :                 pr_devel("DRBG: requested random numbers too large %u\n",
    1355                 :            :                          buflen);
    1356                 :          0 :                 goto err;
    1357                 :            :         }
    1358                 :            : 
    1359                 :            :         /* 9.3.1 step 3 is implicit with the chosen DRBG */
    1360                 :            : 
    1361                 :            :         /* 9.3.1 step 4 */
    1362   [ #  #  #  # ]:          0 :         if (addtl && addtl->len > (drbg_max_addtl(drbg))) {
    1363                 :          0 :                 pr_devel("DRBG: additional information string too long %zu\n",
    1364                 :            :                          addtl->len);
    1365                 :          0 :                 goto err;
    1366                 :            :         }
    1367                 :            :         /* 9.3.1 step 5 is implicit with the chosen DRBG */
    1368                 :            : 
    1369                 :            :         /*
    1370                 :            :          * 9.3.1 step 6 and 9 supplemented by 9.3.2 step c is implemented
    1371                 :            :          * here. The spec is a bit convoluted here, we make it simpler.
    1372                 :            :          */
    1373         [ #  # ]:          0 :         if (drbg->reseed_threshold < drbg->reseed_ctr)
    1374                 :          0 :                 drbg->seeded = false;
    1375                 :            : 
    1376   [ #  #  #  # ]:          0 :         if (drbg->pr || !drbg->seeded) {
    1377                 :          0 :                 pr_devel("DRBG: reseeding before generation (prediction "
    1378                 :            :                          "resistance: %s, state %s)\n",
    1379                 :            :                          drbg->pr ? "true" : "false",
    1380                 :            :                          drbg->seeded ? "seeded" : "unseeded");
    1381                 :            :                 /* 9.3.1 steps 7.1 through 7.3 */
    1382                 :          0 :                 len = drbg_seed(drbg, addtl, true);
    1383         [ #  # ]:          0 :                 if (len)
    1384                 :          0 :                         goto err;
    1385                 :            :                 /* 9.3.1 step 7.4 */
    1386                 :            :                 addtl = NULL;
    1387                 :            :         }
    1388                 :            : 
    1389   [ #  #  #  # ]:          0 :         if (addtl && 0 < addtl->len)
    1390                 :          0 :                 list_add_tail(&addtl->list, &addtllist);
    1391                 :            :         /* 9.3.1 step 8 and 10 */
    1392                 :          0 :         len = drbg->d_ops->generate(drbg, buf, buflen, &addtllist);
    1393                 :            : 
    1394                 :            :         /* 10.1.1.4 step 6, 10.1.2.5 step 7, 10.2.1.5.2 step 7 */
    1395                 :          0 :         drbg->reseed_ctr++;
    1396                 :          0 :         if (0 >= len)
    1397                 :            :                 goto err;
    1398                 :            : 
    1399                 :            :         /*
    1400                 :            :          * Section 11.3.3 requires to re-perform self tests after some
    1401                 :            :          * generated random numbers. The chosen value after which self
    1402                 :            :          * test is performed is arbitrary, but it should be reasonable.
    1403                 :            :          * However, we do not perform the self tests because of the following
    1404                 :            :          * reasons: it is mathematically impossible that the initial self tests
    1405                 :            :          * were successfully and the following are not. If the initial would
    1406                 :            :          * pass and the following would not, the kernel integrity is violated.
    1407                 :            :          * In this case, the entire kernel operation is questionable and it
    1408                 :            :          * is unlikely that the integrity violation only affects the
    1409                 :            :          * correct operation of the DRBG.
    1410                 :            :          *
    1411                 :            :          * Albeit the following code is commented out, it is provided in
    1412                 :            :          * case somebody has a need to implement the test of 11.3.3.
    1413                 :            :          */
    1414                 :            : #if 0
    1415                 :            :         if (drbg->reseed_ctr && !(drbg->reseed_ctr % 4096)) {
    1416                 :            :                 int err = 0;
    1417                 :            :                 pr_devel("DRBG: start to perform self test\n");
    1418                 :            :                 if (drbg->core->flags & DRBG_HMAC)
    1419                 :            :                         err = alg_test("drbg_pr_hmac_sha256",
    1420                 :            :                                        "drbg_pr_hmac_sha256", 0, 0);
    1421                 :            :                 else if (drbg->core->flags & DRBG_CTR)
    1422                 :            :                         err = alg_test("drbg_pr_ctr_aes128",
    1423                 :            :                                        "drbg_pr_ctr_aes128", 0, 0);
    1424                 :            :                 else
    1425                 :            :                         err = alg_test("drbg_pr_sha256",
    1426                 :            :                                        "drbg_pr_sha256", 0, 0);
    1427                 :            :                 if (err) {
    1428                 :            :                         pr_err("DRBG: periodical self test failed\n");
    1429                 :            :                         /*
    1430                 :            :                          * uninstantiate implies that from now on, only errors
    1431                 :            :                          * are returned when reusing this DRBG cipher handle
    1432                 :            :                          */
    1433                 :            :                         drbg_uninstantiate(drbg);
    1434                 :            :                         return 0;
    1435                 :            :                 } else {
    1436                 :            :                         pr_devel("DRBG: self test successful\n");
    1437                 :            :                 }
    1438                 :            :         }
    1439                 :            : #endif
    1440                 :            : 
    1441                 :            :         /*
    1442                 :            :          * All operations were successful, return 0 as mandated by
    1443                 :            :          * the kernel crypto API interface.
    1444                 :            :          */
    1445                 :            :         len = 0;
    1446                 :            : err:
    1447                 :            :         return len;
    1448                 :            : }
    1449                 :            : 
    1450                 :            : /*
    1451                 :            :  * Wrapper around drbg_generate which can pull arbitrary long strings
    1452                 :            :  * from the DRBG without hitting the maximum request limitation.
    1453                 :            :  *
    1454                 :            :  * Parameters: see drbg_generate
    1455                 :            :  * Return codes: see drbg_generate -- if one drbg_generate request fails,
    1456                 :            :  *               the entire drbg_generate_long request fails
    1457                 :            :  */
    1458                 :          0 : static int drbg_generate_long(struct drbg_state *drbg,
    1459                 :            :                               unsigned char *buf, unsigned int buflen,
    1460                 :            :                               struct drbg_string *addtl)
    1461                 :            : {
    1462                 :          0 :         unsigned int len = 0;
    1463                 :          0 :         unsigned int slice = 0;
    1464                 :          0 :         do {
    1465                 :          0 :                 int err = 0;
    1466                 :          0 :                 unsigned int chunk = 0;
    1467         [ #  # ]:          0 :                 slice = ((buflen - len) / drbg_max_request_bytes(drbg));
    1468         [ #  # ]:          0 :                 chunk = slice ? drbg_max_request_bytes(drbg) : (buflen - len);
    1469                 :          0 :                 mutex_lock(&drbg->drbg_mutex);
    1470                 :          0 :                 err = drbg_generate(drbg, buf + len, chunk, addtl);
    1471                 :          0 :                 mutex_unlock(&drbg->drbg_mutex);
    1472         [ #  # ]:          0 :                 if (0 > err)
    1473                 :          0 :                         return err;
    1474                 :          0 :                 len += chunk;
    1475         [ #  # ]:          0 :         } while (slice > 0 && (len < buflen));
    1476                 :            :         return 0;
    1477                 :            : }
    1478                 :            : 
    1479                 :          0 : static void drbg_schedule_async_seed(struct random_ready_callback *rdy)
    1480                 :            : {
    1481                 :          0 :         struct drbg_state *drbg = container_of(rdy, struct drbg_state,
    1482                 :            :                                                random_ready);
    1483                 :            : 
    1484                 :          0 :         schedule_work(&drbg->seed_work);
    1485                 :          0 : }
    1486                 :            : 
    1487                 :          0 : static int drbg_prepare_hrng(struct drbg_state *drbg)
    1488                 :            : {
    1489                 :          0 :         int err;
    1490                 :            : 
    1491                 :            :         /* We do not need an HRNG in test mode. */
    1492         [ #  # ]:          0 :         if (list_empty(&drbg->test_data.list))
    1493                 :            :                 return 0;
    1494                 :            : 
    1495                 :          0 :         INIT_WORK(&drbg->seed_work, drbg_async_seed);
    1496                 :            : 
    1497                 :          0 :         drbg->random_ready.owner = THIS_MODULE;
    1498                 :          0 :         drbg->random_ready.func = drbg_schedule_async_seed;
    1499                 :            : 
    1500                 :          0 :         err = add_random_ready_callback(&drbg->random_ready);
    1501                 :            : 
    1502      [ #  #  # ]:          0 :         switch (err) {
    1503                 :            :         case 0:
    1504                 :          0 :                 break;
    1505                 :            : 
    1506                 :          0 :         case -EALREADY:
    1507                 :          0 :                 err = 0;
    1508                 :            :                 /* fall through */
    1509                 :            : 
    1510                 :          0 :         default:
    1511                 :          0 :                 drbg->random_ready.func = NULL;
    1512                 :          0 :                 return err;
    1513                 :            :         }
    1514                 :            : 
    1515                 :          0 :         drbg->jent = crypto_alloc_rng("jitterentropy_rng", 0, 0);
    1516                 :            : 
    1517                 :            :         /*
    1518                 :            :          * Require frequent reseeds until the seed source is fully
    1519                 :            :          * initialized.
    1520                 :            :          */
    1521                 :          0 :         drbg->reseed_threshold = 50;
    1522                 :            : 
    1523                 :          0 :         return err;
    1524                 :            : }
    1525                 :            : 
    1526                 :            : /*
    1527                 :            :  * DRBG instantiation function as required by SP800-90A - this function
    1528                 :            :  * sets up the DRBG handle, performs the initial seeding and all sanity
    1529                 :            :  * checks required by SP800-90A
    1530                 :            :  *
    1531                 :            :  * @drbg memory of state -- if NULL, new memory is allocated
    1532                 :            :  * @pers Personalization string that is mixed into state, may be NULL -- note
    1533                 :            :  *       the entropy is pulled by the DRBG internally unconditionally
    1534                 :            :  *       as defined in SP800-90A. The additional input is mixed into
    1535                 :            :  *       the state in addition to the pulled entropy.
    1536                 :            :  * @coreref reference to core
    1537                 :            :  * @pr prediction resistance enabled
    1538                 :            :  *
    1539                 :            :  * return
    1540                 :            :  *      0 on success
    1541                 :            :  *      error value otherwise
    1542                 :            :  */
    1543                 :          0 : static int drbg_instantiate(struct drbg_state *drbg, struct drbg_string *pers,
    1544                 :            :                             int coreref, bool pr)
    1545                 :            : {
    1546                 :          0 :         int ret;
    1547                 :          0 :         bool reseed = true;
    1548                 :            : 
    1549                 :          0 :         pr_devel("DRBG: Initializing DRBG core %d with prediction resistance "
    1550                 :            :                  "%s\n", coreref, pr ? "enabled" : "disabled");
    1551                 :          0 :         mutex_lock(&drbg->drbg_mutex);
    1552                 :            : 
    1553                 :            :         /* 9.1 step 1 is implicit with the selected DRBG type */
    1554                 :            : 
    1555                 :            :         /*
    1556                 :            :          * 9.1 step 2 is implicit as caller can select prediction resistance
    1557                 :            :          * and the flag is copied into drbg->flags --
    1558                 :            :          * all DRBG types support prediction resistance
    1559                 :            :          */
    1560                 :            : 
    1561                 :            :         /* 9.1 step 4 is implicit in  drbg_sec_strength */
    1562                 :            : 
    1563         [ #  # ]:          0 :         if (!drbg->core) {
    1564                 :          0 :                 drbg->core = &drbg_cores[coreref];
    1565                 :          0 :                 drbg->pr = pr;
    1566                 :          0 :                 drbg->seeded = false;
    1567                 :          0 :                 drbg->reseed_threshold = drbg_max_requests(drbg);
    1568                 :            : 
    1569                 :          0 :                 ret = drbg_alloc_state(drbg);
    1570         [ #  # ]:          0 :                 if (ret)
    1571                 :          0 :                         goto unlock;
    1572                 :            : 
    1573                 :          0 :                 ret = drbg_prepare_hrng(drbg);
    1574         [ #  # ]:          0 :                 if (ret)
    1575                 :          0 :                         goto free_everything;
    1576                 :            : 
    1577         [ #  # ]:          0 :                 if (IS_ERR(drbg->jent)) {
    1578         [ #  # ]:          0 :                         ret = PTR_ERR(drbg->jent);
    1579                 :          0 :                         drbg->jent = NULL;
    1580         [ #  # ]:          0 :                         if (fips_enabled || ret != -ENOENT)
    1581                 :          0 :                                 goto free_everything;
    1582                 :          0 :                         pr_info("DRBG: Continuing without Jitter RNG\n");
    1583                 :            :                 }
    1584                 :            : 
    1585                 :            :                 reseed = false;
    1586                 :            :         }
    1587                 :            : 
    1588                 :          0 :         ret = drbg_seed(drbg, pers, reseed);
    1589                 :            : 
    1590         [ #  # ]:          0 :         if (ret && !reseed)
    1591                 :          0 :                 goto free_everything;
    1592                 :            : 
    1593                 :          0 :         mutex_unlock(&drbg->drbg_mutex);
    1594                 :          0 :         return ret;
    1595                 :            : 
    1596                 :            : unlock:
    1597                 :          0 :         mutex_unlock(&drbg->drbg_mutex);
    1598                 :          0 :         return ret;
    1599                 :            : 
    1600                 :          0 : free_everything:
    1601                 :          0 :         mutex_unlock(&drbg->drbg_mutex);
    1602                 :          0 :         drbg_uninstantiate(drbg);
    1603                 :          0 :         return ret;
    1604                 :            : }
    1605                 :            : 
    1606                 :            : /*
    1607                 :            :  * DRBG uninstantiate function as required by SP800-90A - this function
    1608                 :            :  * frees all buffers and the DRBG handle
    1609                 :            :  *
    1610                 :            :  * @drbg DRBG state handle
    1611                 :            :  *
    1612                 :            :  * return
    1613                 :            :  *      0 on success
    1614                 :            :  */
    1615                 :          0 : static int drbg_uninstantiate(struct drbg_state *drbg)
    1616                 :            : {
    1617         [ #  # ]:          0 :         if (drbg->random_ready.func) {
    1618                 :          0 :                 del_random_ready_callback(&drbg->random_ready);
    1619                 :          0 :                 cancel_work_sync(&drbg->seed_work);
    1620                 :          0 :                 crypto_free_rng(drbg->jent);
    1621                 :          0 :                 drbg->jent = NULL;
    1622                 :            :         }
    1623                 :            : 
    1624         [ #  # ]:          0 :         if (drbg->d_ops)
    1625                 :          0 :                 drbg->d_ops->crypto_fini(drbg);
    1626                 :          0 :         drbg_dealloc_state(drbg);
    1627                 :            :         /* no scrubbing of test_data -- this shall survive an uninstantiate */
    1628                 :          0 :         return 0;
    1629                 :            : }
    1630                 :            : 
    1631                 :            : /*
    1632                 :            :  * Helper function for setting the test data in the DRBG
    1633                 :            :  *
    1634                 :            :  * @drbg DRBG state handle
    1635                 :            :  * @data test data
    1636                 :            :  * @len test data length
    1637                 :            :  */
    1638                 :          0 : static void drbg_kcapi_set_entropy(struct crypto_rng *tfm,
    1639                 :            :                                    const u8 *data, unsigned int len)
    1640                 :            : {
    1641                 :          0 :         struct drbg_state *drbg = crypto_rng_ctx(tfm);
    1642                 :            : 
    1643                 :          0 :         mutex_lock(&drbg->drbg_mutex);
    1644                 :          0 :         drbg_string_fill(&drbg->test_data, data, len);
    1645                 :          0 :         mutex_unlock(&drbg->drbg_mutex);
    1646                 :          0 : }
    1647                 :            : 
    1648                 :            : /***************************************************************
    1649                 :            :  * Kernel crypto API cipher invocations requested by DRBG
    1650                 :            :  ***************************************************************/
    1651                 :            : 
    1652                 :            : #if defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_HMAC)
    1653                 :            : struct sdesc {
    1654                 :            :         struct shash_desc shash;
    1655                 :            :         char ctx[];
    1656                 :            : };
    1657                 :            : 
    1658                 :          0 : static int drbg_init_hash_kernel(struct drbg_state *drbg)
    1659                 :            : {
    1660                 :          0 :         struct sdesc *sdesc;
    1661                 :          0 :         struct crypto_shash *tfm;
    1662                 :            : 
    1663                 :          0 :         tfm = crypto_alloc_shash(drbg->core->backend_cra_name, 0, 0);
    1664         [ #  # ]:          0 :         if (IS_ERR(tfm)) {
    1665                 :          0 :                 pr_info("DRBG: could not allocate digest TFM handle: %s\n",
    1666                 :            :                                 drbg->core->backend_cra_name);
    1667                 :          0 :                 return PTR_ERR(tfm);
    1668                 :            :         }
    1669   [ #  #  #  # ]:          0 :         BUG_ON(drbg_blocklen(drbg) != crypto_shash_digestsize(tfm));
    1670                 :          0 :         sdesc = kzalloc(sizeof(struct shash_desc) + crypto_shash_descsize(tfm),
    1671                 :            :                         GFP_KERNEL);
    1672         [ #  # ]:          0 :         if (!sdesc) {
    1673                 :          0 :                 crypto_free_shash(tfm);
    1674                 :          0 :                 return -ENOMEM;
    1675                 :            :         }
    1676                 :            : 
    1677                 :          0 :         sdesc->shash.tfm = tfm;
    1678                 :          0 :         drbg->priv_data = sdesc;
    1679                 :            : 
    1680                 :          0 :         return crypto_shash_alignmask(tfm);
    1681                 :            : }
    1682                 :            : 
    1683                 :          0 : static int drbg_fini_hash_kernel(struct drbg_state *drbg)
    1684                 :            : {
    1685                 :          0 :         struct sdesc *sdesc = (struct sdesc *)drbg->priv_data;
    1686         [ #  # ]:          0 :         if (sdesc) {
    1687                 :          0 :                 crypto_free_shash(sdesc->shash.tfm);
    1688                 :          0 :                 kzfree(sdesc);
    1689                 :            :         }
    1690                 :          0 :         drbg->priv_data = NULL;
    1691                 :          0 :         return 0;
    1692                 :            : }
    1693                 :            : 
    1694                 :          0 : static void drbg_kcapi_hmacsetkey(struct drbg_state *drbg,
    1695                 :            :                                   const unsigned char *key)
    1696                 :            : {
    1697                 :          0 :         struct sdesc *sdesc = (struct sdesc *)drbg->priv_data;
    1698                 :            : 
    1699         [ #  # ]:          0 :         crypto_shash_setkey(sdesc->shash.tfm, key, drbg_statelen(drbg));
    1700                 :          0 : }
    1701                 :            : 
    1702                 :            : static int drbg_kcapi_hash(struct drbg_state *drbg, unsigned char *outval,
    1703                 :            :                            const struct list_head *in)
    1704                 :            : {
    1705                 :            :         struct sdesc *sdesc = (struct sdesc *)drbg->priv_data;
    1706                 :            :         struct drbg_string *input = NULL;
    1707                 :            : 
    1708                 :            :         crypto_shash_init(&sdesc->shash);
    1709                 :            :         list_for_each_entry(input, in, list)
    1710                 :            :                 crypto_shash_update(&sdesc->shash, input->buf, input->len);
    1711                 :            :         return crypto_shash_final(&sdesc->shash, outval);
    1712                 :            : }
    1713                 :            : #endif /* (CONFIG_CRYPTO_DRBG_HASH || CONFIG_CRYPTO_DRBG_HMAC) */
    1714                 :            : 
    1715                 :            : #ifdef CONFIG_CRYPTO_DRBG_CTR
    1716                 :            : static int drbg_fini_sym_kernel(struct drbg_state *drbg)
    1717                 :            : {
    1718                 :            :         struct crypto_cipher *tfm =
    1719                 :            :                 (struct crypto_cipher *)drbg->priv_data;
    1720                 :            :         if (tfm)
    1721                 :            :                 crypto_free_cipher(tfm);
    1722                 :            :         drbg->priv_data = NULL;
    1723                 :            : 
    1724                 :            :         if (drbg->ctr_handle)
    1725                 :            :                 crypto_free_skcipher(drbg->ctr_handle);
    1726                 :            :         drbg->ctr_handle = NULL;
    1727                 :            : 
    1728                 :            :         if (drbg->ctr_req)
    1729                 :            :                 skcipher_request_free(drbg->ctr_req);
    1730                 :            :         drbg->ctr_req = NULL;
    1731                 :            : 
    1732                 :            :         kfree(drbg->outscratchpadbuf);
    1733                 :            :         drbg->outscratchpadbuf = NULL;
    1734                 :            : 
    1735                 :            :         return 0;
    1736                 :            : }
    1737                 :            : 
    1738                 :            : static int drbg_init_sym_kernel(struct drbg_state *drbg)
    1739                 :            : {
    1740                 :            :         struct crypto_cipher *tfm;
    1741                 :            :         struct crypto_skcipher *sk_tfm;
    1742                 :            :         struct skcipher_request *req;
    1743                 :            :         unsigned int alignmask;
    1744                 :            :         char ctr_name[CRYPTO_MAX_ALG_NAME];
    1745                 :            : 
    1746                 :            :         tfm = crypto_alloc_cipher(drbg->core->backend_cra_name, 0, 0);
    1747                 :            :         if (IS_ERR(tfm)) {
    1748                 :            :                 pr_info("DRBG: could not allocate cipher TFM handle: %s\n",
    1749                 :            :                                 drbg->core->backend_cra_name);
    1750                 :            :                 return PTR_ERR(tfm);
    1751                 :            :         }
    1752                 :            :         BUG_ON(drbg_blocklen(drbg) != crypto_cipher_blocksize(tfm));
    1753                 :            :         drbg->priv_data = tfm;
    1754                 :            : 
    1755                 :            :         if (snprintf(ctr_name, CRYPTO_MAX_ALG_NAME, "ctr(%s)",
    1756                 :            :             drbg->core->backend_cra_name) >= CRYPTO_MAX_ALG_NAME) {
    1757                 :            :                 drbg_fini_sym_kernel(drbg);
    1758                 :            :                 return -EINVAL;
    1759                 :            :         }
    1760                 :            :         sk_tfm = crypto_alloc_skcipher(ctr_name, 0, 0);
    1761                 :            :         if (IS_ERR(sk_tfm)) {
    1762                 :            :                 pr_info("DRBG: could not allocate CTR cipher TFM handle: %s\n",
    1763                 :            :                                 ctr_name);
    1764                 :            :                 drbg_fini_sym_kernel(drbg);
    1765                 :            :                 return PTR_ERR(sk_tfm);
    1766                 :            :         }
    1767                 :            :         drbg->ctr_handle = sk_tfm;
    1768                 :            :         crypto_init_wait(&drbg->ctr_wait);
    1769                 :            : 
    1770                 :            :         req = skcipher_request_alloc(sk_tfm, GFP_KERNEL);
    1771                 :            :         if (!req) {
    1772                 :            :                 pr_info("DRBG: could not allocate request queue\n");
    1773                 :            :                 drbg_fini_sym_kernel(drbg);
    1774                 :            :                 return -ENOMEM;
    1775                 :            :         }
    1776                 :            :         drbg->ctr_req = req;
    1777                 :            :         skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |
    1778                 :            :                                                 CRYPTO_TFM_REQ_MAY_SLEEP,
    1779                 :            :                                         crypto_req_done, &drbg->ctr_wait);
    1780                 :            : 
    1781                 :            :         alignmask = crypto_skcipher_alignmask(sk_tfm);
    1782                 :            :         drbg->outscratchpadbuf = kmalloc(DRBG_OUTSCRATCHLEN + alignmask,
    1783                 :            :                                          GFP_KERNEL);
    1784                 :            :         if (!drbg->outscratchpadbuf) {
    1785                 :            :                 drbg_fini_sym_kernel(drbg);
    1786                 :            :                 return -ENOMEM;
    1787                 :            :         }
    1788                 :            :         drbg->outscratchpad = (u8 *)PTR_ALIGN(drbg->outscratchpadbuf,
    1789                 :            :                                               alignmask + 1);
    1790                 :            : 
    1791                 :            :         sg_init_table(&drbg->sg_in, 1);
    1792                 :            :         sg_init_one(&drbg->sg_out, drbg->outscratchpad, DRBG_OUTSCRATCHLEN);
    1793                 :            : 
    1794                 :            :         return alignmask;
    1795                 :            : }
    1796                 :            : 
    1797                 :            : static void drbg_kcapi_symsetkey(struct drbg_state *drbg,
    1798                 :            :                                  const unsigned char *key)
    1799                 :            : {
    1800                 :            :         struct crypto_cipher *tfm =
    1801                 :            :                 (struct crypto_cipher *)drbg->priv_data;
    1802                 :            : 
    1803                 :            :         crypto_cipher_setkey(tfm, key, (drbg_keylen(drbg)));
    1804                 :            : }
    1805                 :            : 
    1806                 :            : static int drbg_kcapi_sym(struct drbg_state *drbg, unsigned char *outval,
    1807                 :            :                           const struct drbg_string *in)
    1808                 :            : {
    1809                 :            :         struct crypto_cipher *tfm =
    1810                 :            :                 (struct crypto_cipher *)drbg->priv_data;
    1811                 :            : 
    1812                 :            :         /* there is only component in *in */
    1813                 :            :         BUG_ON(in->len < drbg_blocklen(drbg));
    1814                 :            :         crypto_cipher_encrypt_one(tfm, outval, in->buf);
    1815                 :            :         return 0;
    1816                 :            : }
    1817                 :            : 
    1818                 :            : static int drbg_kcapi_sym_ctr(struct drbg_state *drbg,
    1819                 :            :                               u8 *inbuf, u32 inlen,
    1820                 :            :                               u8 *outbuf, u32 outlen)
    1821                 :            : {
    1822                 :            :         struct scatterlist *sg_in = &drbg->sg_in, *sg_out = &drbg->sg_out;
    1823                 :            :         u32 scratchpad_use = min_t(u32, outlen, DRBG_OUTSCRATCHLEN);
    1824                 :            :         int ret;
    1825                 :            : 
    1826                 :            :         if (inbuf) {
    1827                 :            :                 /* Use caller-provided input buffer */
    1828                 :            :                 sg_set_buf(sg_in, inbuf, inlen);
    1829                 :            :         } else {
    1830                 :            :                 /* Use scratchpad for in-place operation */
    1831                 :            :                 inlen = scratchpad_use;
    1832                 :            :                 memset(drbg->outscratchpad, 0, scratchpad_use);
    1833                 :            :                 sg_set_buf(sg_in, drbg->outscratchpad, scratchpad_use);
    1834                 :            :         }
    1835                 :            : 
    1836                 :            :         while (outlen) {
    1837                 :            :                 u32 cryptlen = min3(inlen, outlen, (u32)DRBG_OUTSCRATCHLEN);
    1838                 :            : 
    1839                 :            :                 /* Output buffer may not be valid for SGL, use scratchpad */
    1840                 :            :                 skcipher_request_set_crypt(drbg->ctr_req, sg_in, sg_out,
    1841                 :            :                                            cryptlen, drbg->V);
    1842                 :            :                 ret = crypto_wait_req(crypto_skcipher_encrypt(drbg->ctr_req),
    1843                 :            :                                         &drbg->ctr_wait);
    1844                 :            :                 if (ret)
    1845                 :            :                         goto out;
    1846                 :            : 
    1847                 :            :                 crypto_init_wait(&drbg->ctr_wait);
    1848                 :            : 
    1849                 :            :                 memcpy(outbuf, drbg->outscratchpad, cryptlen);
    1850                 :            :                 memzero_explicit(drbg->outscratchpad, cryptlen);
    1851                 :            : 
    1852                 :            :                 outlen -= cryptlen;
    1853                 :            :                 outbuf += cryptlen;
    1854                 :            :         }
    1855                 :            :         ret = 0;
    1856                 :            : 
    1857                 :            : out:
    1858                 :            :         return ret;
    1859                 :            : }
    1860                 :            : #endif /* CONFIG_CRYPTO_DRBG_CTR */
    1861                 :            : 
    1862                 :            : /***************************************************************
    1863                 :            :  * Kernel crypto API interface to register DRBG
    1864                 :            :  ***************************************************************/
    1865                 :            : 
    1866                 :            : /*
    1867                 :            :  * Look up the DRBG flags by given kernel crypto API cra_name
    1868                 :            :  * The code uses the drbg_cores definition to do this
    1869                 :            :  *
    1870                 :            :  * @cra_name kernel crypto API cra_name
    1871                 :            :  * @coreref reference to integer which is filled with the pointer to
    1872                 :            :  *  the applicable core
    1873                 :            :  * @pr reference for setting prediction resistance
    1874                 :            :  *
    1875                 :            :  * return: flags
    1876                 :            :  */
    1877                 :          0 : static inline void drbg_convert_tfm_core(const char *cra_driver_name,
    1878                 :            :                                          int *coreref, bool *pr)
    1879                 :            : {
    1880                 :          0 :         int i = 0;
    1881                 :          0 :         size_t start = 0;
    1882                 :          0 :         int len = 0;
    1883                 :            : 
    1884                 :          0 :         *pr = true;
    1885                 :            :         /* disassemble the names */
    1886         [ #  # ]:          0 :         if (!memcmp(cra_driver_name, "drbg_nopr_", 10)) {
    1887                 :          0 :                 start = 10;
    1888                 :          0 :                 *pr = false;
    1889         [ #  # ]:          0 :         } else if (!memcmp(cra_driver_name, "drbg_pr_", 8)) {
    1890                 :            :                 start = 8;
    1891                 :            :         } else {
    1892                 :            :                 return;
    1893                 :            :         }
    1894                 :            : 
    1895                 :            :         /* remove the first part */
    1896                 :          0 :         len = strlen(cra_driver_name) - start;
    1897         [ #  # ]:          0 :         for (i = 0; ARRAY_SIZE(drbg_cores) > i; i++) {
    1898         [ #  # ]:          0 :                 if (!memcmp(cra_driver_name + start, drbg_cores[i].cra_name,
    1899                 :            :                             len)) {
    1900                 :          0 :                         *coreref = i;
    1901                 :          0 :                         return;
    1902                 :            :                 }
    1903                 :            :         }
    1904                 :            : }
    1905                 :            : 
    1906                 :          0 : static int drbg_kcapi_init(struct crypto_tfm *tfm)
    1907                 :            : {
    1908                 :          0 :         struct drbg_state *drbg = crypto_tfm_ctx(tfm);
    1909                 :            : 
    1910                 :          0 :         mutex_init(&drbg->drbg_mutex);
    1911                 :            : 
    1912                 :          0 :         return 0;
    1913                 :            : }
    1914                 :            : 
    1915                 :          0 : static void drbg_kcapi_cleanup(struct crypto_tfm *tfm)
    1916                 :            : {
    1917                 :          0 :         drbg_uninstantiate(crypto_tfm_ctx(tfm));
    1918                 :          0 : }
    1919                 :            : 
    1920                 :            : /*
    1921                 :            :  * Generate random numbers invoked by the kernel crypto API:
    1922                 :            :  * The API of the kernel crypto API is extended as follows:
    1923                 :            :  *
    1924                 :            :  * src is additional input supplied to the RNG.
    1925                 :            :  * slen is the length of src.
    1926                 :            :  * dst is the output buffer where random data is to be stored.
    1927                 :            :  * dlen is the length of dst.
    1928                 :            :  */
    1929                 :          0 : static int drbg_kcapi_random(struct crypto_rng *tfm,
    1930                 :            :                              const u8 *src, unsigned int slen,
    1931                 :            :                              u8 *dst, unsigned int dlen)
    1932                 :            : {
    1933         [ #  # ]:          0 :         struct drbg_state *drbg = crypto_rng_ctx(tfm);
    1934                 :          0 :         struct drbg_string *addtl = NULL;
    1935                 :          0 :         struct drbg_string string;
    1936                 :            : 
    1937         [ #  # ]:          0 :         if (slen) {
    1938                 :            :                 /* linked list variable is now local to allow modification */
    1939                 :          0 :                 drbg_string_fill(&string, src, slen);
    1940                 :          0 :                 addtl = &string;
    1941                 :            :         }
    1942                 :            : 
    1943                 :          0 :         return drbg_generate_long(drbg, dst, dlen, addtl);
    1944                 :            : }
    1945                 :            : 
    1946                 :            : /*
    1947                 :            :  * Seed the DRBG invoked by the kernel crypto API
    1948                 :            :  */
    1949                 :          0 : static int drbg_kcapi_seed(struct crypto_rng *tfm,
    1950                 :            :                            const u8 *seed, unsigned int slen)
    1951                 :            : {
    1952                 :          0 :         struct drbg_state *drbg = crypto_rng_ctx(tfm);
    1953                 :          0 :         struct crypto_tfm *tfm_base = crypto_rng_tfm(tfm);
    1954                 :          0 :         bool pr = false;
    1955                 :          0 :         struct drbg_string string;
    1956                 :          0 :         struct drbg_string *seed_string = NULL;
    1957                 :          0 :         int coreref = 0;
    1958                 :            : 
    1959                 :          0 :         drbg_convert_tfm_core(crypto_tfm_alg_driver_name(tfm_base), &coreref,
    1960                 :            :                               &pr);
    1961         [ #  # ]:          0 :         if (0 < slen) {
    1962                 :          0 :                 drbg_string_fill(&string, seed, slen);
    1963                 :          0 :                 seed_string = &string;
    1964                 :            :         }
    1965                 :            : 
    1966                 :          0 :         return drbg_instantiate(drbg, seed_string, coreref, pr);
    1967                 :            : }
    1968                 :            : 
    1969                 :            : /***************************************************************
    1970                 :            :  * Kernel module: code to load the module
    1971                 :            :  ***************************************************************/
    1972                 :            : 
    1973                 :            : /*
    1974                 :            :  * Tests as defined in 11.3.2 in addition to the cipher tests: testing
    1975                 :            :  * of the error handling.
    1976                 :            :  *
    1977                 :            :  * Note: testing of failing seed source as defined in 11.3.2 is not applicable
    1978                 :            :  * as seed source of get_random_bytes does not fail.
    1979                 :            :  *
    1980                 :            :  * Note 2: There is no sensible way of testing the reseed counter
    1981                 :            :  * enforcement, so skip it.
    1982                 :            :  */
    1983                 :         78 : static inline int __init drbg_healthcheck_sanity(void)
    1984                 :            : {
    1985                 :         78 :         int len = 0;
    1986                 :            : #define OUTBUFLEN 16
    1987                 :         78 :         unsigned char buf[OUTBUFLEN];
    1988                 :         78 :         struct drbg_state *drbg = NULL;
    1989                 :         78 :         int ret = -EFAULT;
    1990                 :         78 :         int rc = -EFAULT;
    1991                 :         78 :         bool pr = false;
    1992                 :         78 :         int coreref = 0;
    1993                 :         78 :         struct drbg_string addtl;
    1994                 :         78 :         size_t max_addtllen, max_request_bytes;
    1995                 :            : 
    1996                 :            :         /* only perform test in FIPS mode */
    1997                 :         78 :         if (!fips_enabled)
    1998                 :         78 :                 return 0;
    1999                 :            : 
    2000                 :            : #ifdef CONFIG_CRYPTO_DRBG_CTR
    2001                 :            :         drbg_convert_tfm_core("drbg_nopr_ctr_aes128", &coreref, &pr);
    2002                 :            : #elif defined CONFIG_CRYPTO_DRBG_HASH
    2003                 :            :         drbg_convert_tfm_core("drbg_nopr_sha256", &coreref, &pr);
    2004                 :            : #else
    2005                 :            :         drbg_convert_tfm_core("drbg_nopr_hmac_sha256", &coreref, &pr);
    2006                 :            : #endif
    2007                 :            : 
    2008                 :            :         drbg = kzalloc(sizeof(struct drbg_state), GFP_KERNEL);
    2009                 :            :         if (!drbg)
    2010                 :            :                 return -ENOMEM;
    2011                 :            : 
    2012                 :            :         mutex_init(&drbg->drbg_mutex);
    2013                 :            :         drbg->core = &drbg_cores[coreref];
    2014                 :            :         drbg->reseed_threshold = drbg_max_requests(drbg);
    2015                 :            : 
    2016                 :            :         /*
    2017                 :            :          * if the following tests fail, it is likely that there is a buffer
    2018                 :            :          * overflow as buf is much smaller than the requested or provided
    2019                 :            :          * string lengths -- in case the error handling does not succeed
    2020                 :            :          * we may get an OOPS. And we want to get an OOPS as this is a
    2021                 :            :          * grave bug.
    2022                 :            :          */
    2023                 :            : 
    2024                 :            :         max_addtllen = drbg_max_addtl(drbg);
    2025                 :            :         max_request_bytes = drbg_max_request_bytes(drbg);
    2026                 :            :         drbg_string_fill(&addtl, buf, max_addtllen + 1);
    2027                 :            :         /* overflow addtllen with additonal info string */
    2028                 :            :         len = drbg_generate(drbg, buf, OUTBUFLEN, &addtl);
    2029                 :            :         BUG_ON(0 < len);
    2030                 :            :         /* overflow max_bits */
    2031                 :            :         len = drbg_generate(drbg, buf, (max_request_bytes + 1), NULL);
    2032                 :            :         BUG_ON(0 < len);
    2033                 :            : 
    2034                 :            :         /* overflow max addtllen with personalization string */
    2035                 :            :         ret = drbg_seed(drbg, &addtl, false);
    2036                 :            :         BUG_ON(0 == ret);
    2037                 :            :         /* all tests passed */
    2038                 :            :         rc = 0;
    2039                 :            : 
    2040                 :            :         pr_devel("DRBG: Sanity tests for failure code paths successfully "
    2041                 :            :                  "completed\n");
    2042                 :            : 
    2043                 :            :         kfree(drbg);
    2044                 :            :         return rc;
    2045                 :            : }
    2046                 :            : 
    2047                 :            : static struct rng_alg drbg_algs[22];
    2048                 :            : 
    2049                 :            : /*
    2050                 :            :  * Fill the array drbg_algs used to register the different DRBGs
    2051                 :            :  * with the kernel crypto API. To fill the array, the information
    2052                 :            :  * from drbg_cores[] is used.
    2053                 :            :  */
    2054                 :        624 : static inline void __init drbg_fill_array(struct rng_alg *alg,
    2055                 :            :                                           const struct drbg_core *core, int pr)
    2056                 :            : {
    2057                 :        624 :         int pos = 0;
    2058                 :        624 :         static int priority = 200;
    2059                 :            : 
    2060                 :        624 :         memcpy(alg->base.cra_name, "stdrng", 6);
    2061         [ +  + ]:        624 :         if (pr) {
    2062                 :        312 :                 memcpy(alg->base.cra_driver_name, "drbg_pr_", 8);
    2063                 :        312 :                 pos = 8;
    2064                 :            :         } else {
    2065                 :        312 :                 memcpy(alg->base.cra_driver_name, "drbg_nopr_", 10);
    2066                 :        312 :                 pos = 10;
    2067                 :            :         }
    2068                 :        624 :         memcpy(alg->base.cra_driver_name + pos, core->cra_name,
    2069                 :        624 :                strlen(core->cra_name));
    2070                 :            : 
    2071                 :        624 :         alg->base.cra_priority = priority;
    2072                 :        624 :         priority++;
    2073                 :            :         /*
    2074                 :            :          * If FIPS mode enabled, the selected DRBG shall have the
    2075                 :            :          * highest cra_priority over other stdrng instances to ensure
    2076                 :            :          * it is selected.
    2077                 :            :          */
    2078                 :        624 :         if (fips_enabled)
    2079                 :            :                 alg->base.cra_priority += 200;
    2080                 :            : 
    2081                 :        624 :         alg->base.cra_ctxsize        = sizeof(struct drbg_state);
    2082                 :        624 :         alg->base.cra_module = THIS_MODULE;
    2083                 :        624 :         alg->base.cra_init   = drbg_kcapi_init;
    2084                 :        624 :         alg->base.cra_exit   = drbg_kcapi_cleanup;
    2085                 :        624 :         alg->generate                = drbg_kcapi_random;
    2086                 :        624 :         alg->seed            = drbg_kcapi_seed;
    2087                 :        624 :         alg->set_ent         = drbg_kcapi_set_entropy;
    2088                 :        624 :         alg->seedsize                = 0;
    2089                 :        624 : }
    2090                 :            : 
    2091                 :         78 : static int __init drbg_init(void)
    2092                 :            : {
    2093                 :         78 :         unsigned int i = 0; /* pointer to drbg_algs */
    2094                 :         78 :         unsigned int j = 0; /* pointer to drbg_cores */
    2095                 :         78 :         int ret;
    2096                 :            : 
    2097                 :         78 :         ret = drbg_healthcheck_sanity();
    2098                 :         78 :         if (ret)
    2099                 :            :                 return ret;
    2100                 :            : 
    2101                 :         78 :         if (ARRAY_SIZE(drbg_cores) * 2 > ARRAY_SIZE(drbg_algs)) {
    2102                 :            :                 pr_info("DRBG: Cannot register all DRBG types"
    2103                 :            :                         "(slots needed: %zu, slots available: %zu)\n",
    2104                 :            :                         ARRAY_SIZE(drbg_cores) * 2, ARRAY_SIZE(drbg_algs));
    2105                 :            :                 return -EFAULT;
    2106                 :            :         }
    2107                 :            : 
    2108                 :            :         /*
    2109                 :            :          * each DRBG definition can be used with PR and without PR, thus
    2110                 :            :          * we instantiate each DRBG in drbg_cores[] twice.
    2111                 :            :          *
    2112                 :            :          * As the order of placing them into the drbg_algs array matters
    2113                 :            :          * (the later DRBGs receive a higher cra_priority) we register the
    2114                 :            :          * prediction resistance DRBGs first as the should not be too
    2115                 :            :          * interesting.
    2116                 :            :          */
    2117         [ +  + ]:        390 :         for (j = 0; ARRAY_SIZE(drbg_cores) > j; j++, i++)
    2118                 :        312 :                 drbg_fill_array(&drbg_algs[i], &drbg_cores[j], 1);
    2119         [ +  + ]:        390 :         for (j = 0; ARRAY_SIZE(drbg_cores) > j; j++, i++)
    2120                 :        312 :                 drbg_fill_array(&drbg_algs[i], &drbg_cores[j], 0);
    2121                 :         78 :         return crypto_register_rngs(drbg_algs, (ARRAY_SIZE(drbg_cores) * 2));
    2122                 :            : }
    2123                 :            : 
    2124                 :          0 : static void __exit drbg_exit(void)
    2125                 :            : {
    2126                 :          0 :         crypto_unregister_rngs(drbg_algs, (ARRAY_SIZE(drbg_cores) * 2));
    2127                 :          0 : }
    2128                 :            : 
    2129                 :            : subsys_initcall(drbg_init);
    2130                 :            : module_exit(drbg_exit);
    2131                 :            : #ifndef CRYPTO_DRBG_HASH_STRING
    2132                 :            : #define CRYPTO_DRBG_HASH_STRING ""
    2133                 :            : #endif
    2134                 :            : #ifndef CRYPTO_DRBG_HMAC_STRING
    2135                 :            : #define CRYPTO_DRBG_HMAC_STRING ""
    2136                 :            : #endif
    2137                 :            : #ifndef CRYPTO_DRBG_CTR_STRING
    2138                 :            : #define CRYPTO_DRBG_CTR_STRING ""
    2139                 :            : #endif
    2140                 :            : MODULE_LICENSE("GPL");
    2141                 :            : MODULE_AUTHOR("Stephan Mueller <smueller@chronox.de>");
    2142                 :            : MODULE_DESCRIPTION("NIST SP800-90A Deterministic Random Bit Generator (DRBG) "
    2143                 :            :                    "using following cores: "
    2144                 :            :                    CRYPTO_DRBG_HASH_STRING
    2145                 :            :                    CRYPTO_DRBG_HMAC_STRING
    2146                 :            :                    CRYPTO_DRBG_CTR_STRING);
    2147                 :            : MODULE_ALIAS_CRYPTO("stdrng");

Generated by: LCOV version 1.14