LCOV - code coverage report
Current view: top level - crypto - ccm.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 2 533 0.4 %
Date: 2022-04-01 13:59:58 Functions: 1 34 2.9 %
Branches: 0 212 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * CCM: Counter with CBC-MAC
       4                 :            :  *
       5                 :            :  * (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com>
       6                 :            :  */
       7                 :            : 
       8                 :            : #include <crypto/internal/aead.h>
       9                 :            : #include <crypto/internal/hash.h>
      10                 :            : #include <crypto/internal/skcipher.h>
      11                 :            : #include <crypto/scatterwalk.h>
      12                 :            : #include <linux/err.h>
      13                 :            : #include <linux/init.h>
      14                 :            : #include <linux/kernel.h>
      15                 :            : #include <linux/module.h>
      16                 :            : #include <linux/slab.h>
      17                 :            : 
      18                 :            : struct ccm_instance_ctx {
      19                 :            :         struct crypto_skcipher_spawn ctr;
      20                 :            :         struct crypto_ahash_spawn mac;
      21                 :            : };
      22                 :            : 
      23                 :            : struct crypto_ccm_ctx {
      24                 :            :         struct crypto_ahash *mac;
      25                 :            :         struct crypto_skcipher *ctr;
      26                 :            : };
      27                 :            : 
      28                 :            : struct crypto_rfc4309_ctx {
      29                 :            :         struct crypto_aead *child;
      30                 :            :         u8 nonce[3];
      31                 :            : };
      32                 :            : 
      33                 :            : struct crypto_rfc4309_req_ctx {
      34                 :            :         struct scatterlist src[3];
      35                 :            :         struct scatterlist dst[3];
      36                 :            :         struct aead_request subreq;
      37                 :            : };
      38                 :            : 
      39                 :            : struct crypto_ccm_req_priv_ctx {
      40                 :            :         u8 odata[16];
      41                 :            :         u8 idata[16];
      42                 :            :         u8 auth_tag[16];
      43                 :            :         u32 flags;
      44                 :            :         struct scatterlist src[3];
      45                 :            :         struct scatterlist dst[3];
      46                 :            :         union {
      47                 :            :                 struct ahash_request ahreq;
      48                 :            :                 struct skcipher_request skreq;
      49                 :            :         };
      50                 :            : };
      51                 :            : 
      52                 :            : struct cbcmac_tfm_ctx {
      53                 :            :         struct crypto_cipher *child;
      54                 :            : };
      55                 :            : 
      56                 :            : struct cbcmac_desc_ctx {
      57                 :            :         unsigned int len;
      58                 :            : };
      59                 :            : 
      60                 :          0 : static inline struct crypto_ccm_req_priv_ctx *crypto_ccm_reqctx(
      61                 :            :         struct aead_request *req)
      62                 :            : {
      63                 :          0 :         unsigned long align = crypto_aead_alignmask(crypto_aead_reqtfm(req));
      64                 :            : 
      65   [ #  #  #  #  :          0 :         return (void *)PTR_ALIGN((u8 *)aead_request_ctx(req), align + 1);
                   #  # ]
      66                 :            : }
      67                 :            : 
      68                 :          0 : static int set_msg_len(u8 *block, unsigned int msglen, int csize)
      69                 :            : {
      70                 :          0 :         __be32 data;
      71                 :            : 
      72                 :          0 :         memset(block, 0, csize);
      73                 :          0 :         block += csize;
      74                 :            : 
      75         [ #  # ]:          0 :         if (csize >= 4)
      76                 :            :                 csize = 4;
      77         [ #  # ]:          0 :         else if (msglen > (1 << (8 * csize)))
      78                 :            :                 return -EOVERFLOW;
      79                 :            : 
      80                 :          0 :         data = cpu_to_be32(msglen);
      81                 :          0 :         memcpy(block - csize, (u8 *)&data + 4 - csize, csize);
      82                 :            : 
      83                 :          0 :         return 0;
      84                 :            : }
      85                 :            : 
      86                 :          0 : static int crypto_ccm_setkey(struct crypto_aead *aead, const u8 *key,
      87                 :            :                              unsigned int keylen)
      88                 :            : {
      89                 :          0 :         struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
      90                 :          0 :         struct crypto_skcipher *ctr = ctx->ctr;
      91                 :          0 :         struct crypto_ahash *mac = ctx->mac;
      92                 :          0 :         int err;
      93                 :            : 
      94                 :          0 :         crypto_skcipher_clear_flags(ctr, CRYPTO_TFM_REQ_MASK);
      95                 :          0 :         crypto_skcipher_set_flags(ctr, crypto_aead_get_flags(aead) &
      96                 :            :                                        CRYPTO_TFM_REQ_MASK);
      97                 :          0 :         err = crypto_skcipher_setkey(ctr, key, keylen);
      98         [ #  # ]:          0 :         if (err)
      99                 :            :                 return err;
     100                 :            : 
     101                 :          0 :         crypto_ahash_clear_flags(mac, CRYPTO_TFM_REQ_MASK);
     102                 :          0 :         crypto_ahash_set_flags(mac, crypto_aead_get_flags(aead) &
     103                 :            :                                     CRYPTO_TFM_REQ_MASK);
     104                 :          0 :         return crypto_ahash_setkey(mac, key, keylen);
     105                 :            : }
     106                 :            : 
     107                 :          0 : static int crypto_ccm_setauthsize(struct crypto_aead *tfm,
     108                 :            :                                   unsigned int authsize)
     109                 :            : {
     110         [ #  # ]:          0 :         switch (authsize) {
     111                 :            :         case 4:
     112                 :            :         case 6:
     113                 :            :         case 8:
     114                 :            :         case 10:
     115                 :            :         case 12:
     116                 :            :         case 14:
     117                 :            :         case 16:
     118                 :          0 :                 break;
     119                 :            :         default:
     120                 :            :                 return -EINVAL;
     121                 :            :         }
     122                 :            : 
     123                 :          0 :         return 0;
     124                 :            : }
     125                 :            : 
     126                 :          0 : static int format_input(u8 *info, struct aead_request *req,
     127                 :            :                         unsigned int cryptlen)
     128                 :            : {
     129         [ #  # ]:          0 :         struct crypto_aead *aead = crypto_aead_reqtfm(req);
     130                 :          0 :         unsigned int lp = req->iv[0];
     131                 :          0 :         unsigned int l = lp + 1;
     132                 :          0 :         unsigned int m;
     133                 :            : 
     134         [ #  # ]:          0 :         m = crypto_aead_authsize(aead);
     135                 :            : 
     136                 :          0 :         memcpy(info, req->iv, 16);
     137                 :            : 
     138                 :            :         /* format control info per RFC 3610 and
     139                 :            :          * NIST Special Publication 800-38C
     140                 :            :          */
     141                 :          0 :         *info |= (8 * ((m - 2) / 2));
     142         [ #  # ]:          0 :         if (req->assoclen)
     143                 :          0 :                 *info |= 64;
     144                 :            : 
     145                 :          0 :         return set_msg_len(info + 16 - l, cryptlen, l);
     146                 :            : }
     147                 :            : 
     148                 :          0 : static int format_adata(u8 *adata, unsigned int a)
     149                 :            : {
     150                 :          0 :         int len = 0;
     151                 :            : 
     152                 :            :         /* add control info for associated data
     153                 :            :          * RFC 3610 and NIST Special Publication 800-38C
     154                 :            :          */
     155                 :          0 :         if (a < 65280) {
     156                 :          0 :                 *(__be16 *)adata = cpu_to_be16(a);
     157                 :          0 :                 len = 2;
     158                 :            :         } else  {
     159                 :          0 :                 *(__be16 *)adata = cpu_to_be16(0xfffe);
     160                 :          0 :                 *(__be32 *)&adata[2] = cpu_to_be32(a);
     161                 :          0 :                 len = 6;
     162                 :            :         }
     163                 :            : 
     164                 :          0 :         return len;
     165                 :            : }
     166                 :            : 
     167                 :          0 : static int crypto_ccm_auth(struct aead_request *req, struct scatterlist *plain,
     168                 :            :                            unsigned int cryptlen)
     169                 :            : {
     170                 :          0 :         struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
     171                 :          0 :         struct crypto_aead *aead = crypto_aead_reqtfm(req);
     172                 :          0 :         struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
     173                 :          0 :         struct ahash_request *ahreq = &pctx->ahreq;
     174                 :          0 :         unsigned int assoclen = req->assoclen;
     175                 :          0 :         struct scatterlist sg[3];
     176                 :          0 :         u8 *odata = pctx->odata;
     177                 :          0 :         u8 *idata = pctx->idata;
     178                 :          0 :         int ilen, err;
     179                 :            : 
     180                 :            :         /* format control data for input */
     181                 :          0 :         err = format_input(odata, req, cryptlen);
     182         [ #  # ]:          0 :         if (err)
     183                 :          0 :                 goto out;
     184                 :            : 
     185                 :          0 :         sg_init_table(sg, 3);
     186                 :          0 :         sg_set_buf(&sg[0], odata, 16);
     187                 :            : 
     188                 :            :         /* format associated data and compute into mac */
     189         [ #  # ]:          0 :         if (assoclen) {
     190         [ #  # ]:          0 :                 ilen = format_adata(idata, assoclen);
     191                 :          0 :                 sg_set_buf(&sg[1], idata, ilen);
     192                 :          0 :                 sg_chain(sg, 3, req->src);
     193                 :            :         } else {
     194                 :          0 :                 ilen = 0;
     195                 :          0 :                 sg_chain(sg, 2, req->src);
     196                 :            :         }
     197                 :            : 
     198         [ #  # ]:          0 :         ahash_request_set_tfm(ahreq, ctx->mac);
     199         [ #  # ]:          0 :         ahash_request_set_callback(ahreq, pctx->flags, NULL, NULL);
     200         [ #  # ]:          0 :         ahash_request_set_crypt(ahreq, sg, NULL, assoclen + ilen + 16);
     201         [ #  # ]:          0 :         err = crypto_ahash_init(ahreq);
     202         [ #  # ]:          0 :         if (err)
     203                 :          0 :                 goto out;
     204                 :          0 :         err = crypto_ahash_update(ahreq);
     205         [ #  # ]:          0 :         if (err)
     206                 :          0 :                 goto out;
     207                 :            : 
     208                 :            :         /* we need to pad the MAC input to a round multiple of the block size */
     209                 :          0 :         ilen = 16 - (assoclen + ilen) % 16;
     210         [ #  # ]:          0 :         if (ilen < 16) {
     211                 :          0 :                 memset(idata, 0, ilen);
     212                 :          0 :                 sg_init_table(sg, 2);
     213                 :          0 :                 sg_set_buf(&sg[0], idata, ilen);
     214         [ #  # ]:          0 :                 if (plain)
     215                 :          0 :                         sg_chain(sg, 2, plain);
     216                 :          0 :                 plain = sg;
     217                 :          0 :                 cryptlen += ilen;
     218                 :            :         }
     219                 :            : 
     220                 :          0 :         ahash_request_set_crypt(ahreq, plain, pctx->odata, cryptlen);
     221                 :          0 :         err = crypto_ahash_finup(ahreq);
     222                 :          0 : out:
     223                 :          0 :         return err;
     224                 :            : }
     225                 :            : 
     226                 :          0 : static void crypto_ccm_encrypt_done(struct crypto_async_request *areq, int err)
     227                 :            : {
     228                 :          0 :         struct aead_request *req = areq->data;
     229         [ #  # ]:          0 :         struct crypto_aead *aead = crypto_aead_reqtfm(req);
     230         [ #  # ]:          0 :         struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
     231                 :          0 :         u8 *odata = pctx->odata;
     232                 :            : 
     233         [ #  # ]:          0 :         if (!err)
     234                 :          0 :                 scatterwalk_map_and_copy(odata, req->dst,
     235                 :          0 :                                          req->assoclen + req->cryptlen,
     236                 :            :                                          crypto_aead_authsize(aead), 1);
     237                 :          0 :         aead_request_complete(req, err);
     238                 :          0 : }
     239                 :            : 
     240                 :          0 : static inline int crypto_ccm_check_iv(const u8 *iv)
     241                 :            : {
     242                 :            :         /* 2 <= L <= 8, so 1 <= L' <= 7. */
     243                 :          0 :         if (1 > iv[0] || iv[0] > 7)
     244                 :            :                 return -EINVAL;
     245                 :            : 
     246                 :            :         return 0;
     247                 :            : }
     248                 :            : 
     249                 :          0 : static int crypto_ccm_init_crypt(struct aead_request *req, u8 *tag)
     250                 :            : {
     251         [ #  # ]:          0 :         struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
     252                 :          0 :         struct scatterlist *sg;
     253                 :          0 :         u8 *iv = req->iv;
     254                 :          0 :         int err;
     255                 :            : 
     256         [ #  # ]:          0 :         err = crypto_ccm_check_iv(iv);
     257                 :          0 :         if (err)
     258                 :            :                 return err;
     259                 :            : 
     260                 :          0 :         pctx->flags = aead_request_flags(req);
     261                 :            : 
     262                 :            :          /* Note: rfc 3610 and NIST 800-38C require counter of
     263                 :            :          * zero to encrypt auth tag.
     264                 :            :          */
     265                 :          0 :         memset(iv + 15 - iv[0], 0, iv[0] + 1);
     266                 :            : 
     267                 :          0 :         sg_init_table(pctx->src, 3);
     268                 :          0 :         sg_set_buf(pctx->src, tag, 16);
     269                 :          0 :         sg = scatterwalk_ffwd(pctx->src + 1, req->src, req->assoclen);
     270         [ #  # ]:          0 :         if (sg != pctx->src + 1)
     271                 :          0 :                 sg_chain(pctx->src, 2, sg);
     272                 :            : 
     273         [ #  # ]:          0 :         if (req->src != req->dst) {
     274                 :          0 :                 sg_init_table(pctx->dst, 3);
     275                 :          0 :                 sg_set_buf(pctx->dst, tag, 16);
     276                 :          0 :                 sg = scatterwalk_ffwd(pctx->dst + 1, req->dst, req->assoclen);
     277         [ #  # ]:          0 :                 if (sg != pctx->dst + 1)
     278                 :          0 :                         sg_chain(pctx->dst, 2, sg);
     279                 :            :         }
     280                 :            : 
     281                 :            :         return 0;
     282                 :            : }
     283                 :            : 
     284                 :          0 : static int crypto_ccm_encrypt(struct aead_request *req)
     285                 :            : {
     286                 :          0 :         struct crypto_aead *aead = crypto_aead_reqtfm(req);
     287                 :          0 :         struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
     288                 :          0 :         struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
     289                 :          0 :         struct skcipher_request *skreq = &pctx->skreq;
     290                 :          0 :         struct scatterlist *dst;
     291                 :          0 :         unsigned int cryptlen = req->cryptlen;
     292                 :          0 :         u8 *odata = pctx->odata;
     293                 :          0 :         u8 *iv = req->iv;
     294                 :          0 :         int err;
     295                 :            : 
     296                 :          0 :         err = crypto_ccm_init_crypt(req, odata);
     297         [ #  # ]:          0 :         if (err)
     298                 :            :                 return err;
     299                 :            : 
     300                 :          0 :         err = crypto_ccm_auth(req, sg_next(pctx->src), cryptlen);
     301         [ #  # ]:          0 :         if (err)
     302                 :            :                 return err;
     303                 :            : 
     304                 :          0 :         dst = pctx->src;
     305         [ #  # ]:          0 :         if (req->src != req->dst)
     306                 :          0 :                 dst = pctx->dst;
     307                 :            : 
     308                 :          0 :         skcipher_request_set_tfm(skreq, ctx->ctr);
     309                 :          0 :         skcipher_request_set_callback(skreq, pctx->flags,
     310                 :            :                                       crypto_ccm_encrypt_done, req);
     311                 :          0 :         skcipher_request_set_crypt(skreq, pctx->src, dst, cryptlen + 16, iv);
     312                 :          0 :         err = crypto_skcipher_encrypt(skreq);
     313         [ #  # ]:          0 :         if (err)
     314                 :            :                 return err;
     315                 :            : 
     316                 :            :         /* copy authtag to end of dst */
     317                 :          0 :         scatterwalk_map_and_copy(odata, sg_next(dst), cryptlen,
     318                 :            :                                  crypto_aead_authsize(aead), 1);
     319                 :          0 :         return err;
     320                 :            : }
     321                 :            : 
     322                 :          0 : static void crypto_ccm_decrypt_done(struct crypto_async_request *areq,
     323                 :            :                                    int err)
     324                 :            : {
     325                 :          0 :         struct aead_request *req = areq->data;
     326         [ #  # ]:          0 :         struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
     327                 :          0 :         struct crypto_aead *aead = crypto_aead_reqtfm(req);
     328         [ #  # ]:          0 :         unsigned int authsize = crypto_aead_authsize(aead);
     329                 :          0 :         unsigned int cryptlen = req->cryptlen - authsize;
     330                 :          0 :         struct scatterlist *dst;
     331                 :            : 
     332                 :          0 :         pctx->flags = 0;
     333                 :            : 
     334         [ #  # ]:          0 :         dst = sg_next(req->src == req->dst ? pctx->src : pctx->dst);
     335                 :            : 
     336         [ #  # ]:          0 :         if (!err) {
     337                 :          0 :                 err = crypto_ccm_auth(req, dst, cryptlen);
     338   [ #  #  #  # ]:          0 :                 if (!err && crypto_memneq(pctx->auth_tag, pctx->odata, authsize))
     339                 :          0 :                         err = -EBADMSG;
     340                 :            :         }
     341                 :          0 :         aead_request_complete(req, err);
     342                 :          0 : }
     343                 :            : 
     344                 :          0 : static int crypto_ccm_decrypt(struct aead_request *req)
     345                 :            : {
     346                 :          0 :         struct crypto_aead *aead = crypto_aead_reqtfm(req);
     347                 :          0 :         struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
     348                 :          0 :         struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
     349                 :          0 :         struct skcipher_request *skreq = &pctx->skreq;
     350                 :          0 :         struct scatterlist *dst;
     351                 :          0 :         unsigned int authsize = crypto_aead_authsize(aead);
     352                 :          0 :         unsigned int cryptlen = req->cryptlen;
     353                 :          0 :         u8 *authtag = pctx->auth_tag;
     354                 :          0 :         u8 *odata = pctx->odata;
     355                 :          0 :         u8 *iv = pctx->idata;
     356                 :          0 :         int err;
     357                 :            : 
     358                 :          0 :         cryptlen -= authsize;
     359                 :            : 
     360                 :          0 :         err = crypto_ccm_init_crypt(req, authtag);
     361         [ #  # ]:          0 :         if (err)
     362                 :            :                 return err;
     363                 :            : 
     364                 :          0 :         scatterwalk_map_and_copy(authtag, sg_next(pctx->src), cryptlen,
     365                 :            :                                  authsize, 0);
     366                 :            : 
     367                 :          0 :         dst = pctx->src;
     368         [ #  # ]:          0 :         if (req->src != req->dst)
     369                 :          0 :                 dst = pctx->dst;
     370                 :            : 
     371                 :          0 :         memcpy(iv, req->iv, 16);
     372                 :            : 
     373                 :          0 :         skcipher_request_set_tfm(skreq, ctx->ctr);
     374                 :          0 :         skcipher_request_set_callback(skreq, pctx->flags,
     375                 :            :                                       crypto_ccm_decrypt_done, req);
     376                 :          0 :         skcipher_request_set_crypt(skreq, pctx->src, dst, cryptlen + 16, iv);
     377                 :          0 :         err = crypto_skcipher_decrypt(skreq);
     378         [ #  # ]:          0 :         if (err)
     379                 :            :                 return err;
     380                 :            : 
     381                 :          0 :         err = crypto_ccm_auth(req, sg_next(dst), cryptlen);
     382         [ #  # ]:          0 :         if (err)
     383                 :            :                 return err;
     384                 :            : 
     385                 :            :         /* verify */
     386         [ #  # ]:          0 :         if (crypto_memneq(authtag, odata, authsize))
     387                 :          0 :                 return -EBADMSG;
     388                 :            : 
     389                 :            :         return err;
     390                 :            : }
     391                 :            : 
     392                 :          0 : static int crypto_ccm_init_tfm(struct crypto_aead *tfm)
     393                 :            : {
     394                 :          0 :         struct aead_instance *inst = aead_alg_instance(tfm);
     395                 :          0 :         struct ccm_instance_ctx *ictx = aead_instance_ctx(inst);
     396                 :          0 :         struct crypto_ccm_ctx *ctx = crypto_aead_ctx(tfm);
     397                 :          0 :         struct crypto_ahash *mac;
     398                 :          0 :         struct crypto_skcipher *ctr;
     399                 :          0 :         unsigned long align;
     400                 :          0 :         int err;
     401                 :            : 
     402                 :          0 :         mac = crypto_spawn_ahash(&ictx->mac);
     403         [ #  # ]:          0 :         if (IS_ERR(mac))
     404                 :          0 :                 return PTR_ERR(mac);
     405                 :            : 
     406                 :          0 :         ctr = crypto_spawn_skcipher(&ictx->ctr);
     407         [ #  # ]:          0 :         err = PTR_ERR(ctr);
     408         [ #  # ]:          0 :         if (IS_ERR(ctr))
     409                 :          0 :                 goto err_free_mac;
     410                 :            : 
     411                 :          0 :         ctx->mac = mac;
     412                 :          0 :         ctx->ctr = ctr;
     413                 :            : 
     414                 :          0 :         align = crypto_aead_alignmask(tfm);
     415                 :          0 :         align &= ~(crypto_tfm_ctx_alignment() - 1);
     416                 :          0 :         crypto_aead_set_reqsize(
     417                 :            :                 tfm,
     418                 :          0 :                 align + sizeof(struct crypto_ccm_req_priv_ctx) +
     419                 :          0 :                 max(crypto_ahash_reqsize(mac), crypto_skcipher_reqsize(ctr)));
     420                 :            : 
     421                 :          0 :         return 0;
     422                 :            : 
     423                 :            : err_free_mac:
     424                 :          0 :         crypto_free_ahash(mac);
     425                 :          0 :         return err;
     426                 :            : }
     427                 :            : 
     428                 :          0 : static void crypto_ccm_exit_tfm(struct crypto_aead *tfm)
     429                 :            : {
     430                 :          0 :         struct crypto_ccm_ctx *ctx = crypto_aead_ctx(tfm);
     431                 :            : 
     432                 :          0 :         crypto_free_ahash(ctx->mac);
     433                 :          0 :         crypto_free_skcipher(ctx->ctr);
     434                 :          0 : }
     435                 :            : 
     436                 :          0 : static void crypto_ccm_free(struct aead_instance *inst)
     437                 :            : {
     438                 :          0 :         struct ccm_instance_ctx *ctx = aead_instance_ctx(inst);
     439                 :            : 
     440                 :          0 :         crypto_drop_ahash(&ctx->mac);
     441                 :          0 :         crypto_drop_skcipher(&ctx->ctr);
     442                 :          0 :         kfree(inst);
     443                 :          0 : }
     444                 :            : 
     445                 :          0 : static int crypto_ccm_create_common(struct crypto_template *tmpl,
     446                 :            :                                     struct rtattr **tb,
     447                 :            :                                     const char *ctr_name,
     448                 :            :                                     const char *mac_name)
     449                 :            : {
     450                 :          0 :         struct crypto_attr_type *algt;
     451                 :          0 :         u32 mask;
     452                 :          0 :         struct aead_instance *inst;
     453                 :          0 :         struct ccm_instance_ctx *ictx;
     454                 :          0 :         struct skcipher_alg *ctr;
     455                 :          0 :         struct hash_alg_common *mac;
     456                 :          0 :         int err;
     457                 :            : 
     458                 :          0 :         algt = crypto_get_attr_type(tb);
     459         [ #  # ]:          0 :         if (IS_ERR(algt))
     460                 :          0 :                 return PTR_ERR(algt);
     461                 :            : 
     462         [ #  # ]:          0 :         if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
     463                 :            :                 return -EINVAL;
     464                 :            : 
     465                 :          0 :         mask = crypto_requires_sync(algt->type, algt->mask);
     466                 :            : 
     467                 :          0 :         inst = kzalloc(sizeof(*inst) + sizeof(*ictx), GFP_KERNEL);
     468         [ #  # ]:          0 :         if (!inst)
     469                 :            :                 return -ENOMEM;
     470                 :          0 :         ictx = aead_instance_ctx(inst);
     471                 :            : 
     472                 :          0 :         err = crypto_grab_ahash(&ictx->mac, aead_crypto_instance(inst),
     473                 :            :                                 mac_name, 0, CRYPTO_ALG_ASYNC);
     474         [ #  # ]:          0 :         if (err)
     475                 :          0 :                 goto err_free_inst;
     476         [ #  # ]:          0 :         mac = crypto_spawn_ahash_alg(&ictx->mac);
     477                 :            : 
     478                 :          0 :         err = -EINVAL;
     479         [ #  # ]:          0 :         if (strncmp(mac->base.cra_name, "cbcmac(", 7) != 0 ||
     480         [ #  # ]:          0 :             mac->digestsize != 16)
     481                 :          0 :                 goto err_free_inst;
     482                 :            : 
     483                 :          0 :         err = crypto_grab_skcipher(&ictx->ctr, aead_crypto_instance(inst),
     484                 :            :                                    ctr_name, 0, mask);
     485         [ #  # ]:          0 :         if (err)
     486                 :          0 :                 goto err_free_inst;
     487         [ #  # ]:          0 :         ctr = crypto_spawn_skcipher_alg(&ictx->ctr);
     488                 :            : 
     489                 :            :         /* The skcipher algorithm must be CTR mode, using 16-byte blocks. */
     490                 :          0 :         err = -EINVAL;
     491   [ #  #  #  # ]:          0 :         if (strncmp(ctr->base.cra_name, "ctr(", 4) != 0 ||
     492         [ #  # ]:          0 :             crypto_skcipher_alg_ivsize(ctr) != 16 ||
     493         [ #  # ]:          0 :             ctr->base.cra_blocksize != 1)
     494                 :          0 :                 goto err_free_inst;
     495                 :            : 
     496                 :            :         /* ctr and cbcmac must use the same underlying block cipher. */
     497         [ #  # ]:          0 :         if (strcmp(ctr->base.cra_name + 4, mac->base.cra_name + 7) != 0)
     498                 :          0 :                 goto err_free_inst;
     499                 :            : 
     500                 :          0 :         err = -ENAMETOOLONG;
     501         [ #  # ]:          0 :         if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
     502                 :            :                      "ccm(%s", ctr->base.cra_name + 4) >= CRYPTO_MAX_ALG_NAME)
     503                 :          0 :                 goto err_free_inst;
     504                 :            : 
     505                 :          0 :         if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
     506                 :          0 :                      "ccm_base(%s,%s)", ctr->base.cra_driver_name,
     507         [ #  # ]:          0 :                      mac->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
     508                 :          0 :                 goto err_free_inst;
     509                 :            : 
     510                 :          0 :         inst->alg.base.cra_flags = ctr->base.cra_flags & CRYPTO_ALG_ASYNC;
     511                 :          0 :         inst->alg.base.cra_priority = (mac->base.cra_priority +
     512                 :          0 :                                        ctr->base.cra_priority) / 2;
     513                 :          0 :         inst->alg.base.cra_blocksize = 1;
     514                 :          0 :         inst->alg.base.cra_alignmask = mac->base.cra_alignmask |
     515                 :          0 :                                        ctr->base.cra_alignmask;
     516                 :          0 :         inst->alg.ivsize = 16;
     517                 :          0 :         inst->alg.chunksize = crypto_skcipher_alg_chunksize(ctr);
     518                 :          0 :         inst->alg.maxauthsize = 16;
     519                 :          0 :         inst->alg.base.cra_ctxsize = sizeof(struct crypto_ccm_ctx);
     520                 :          0 :         inst->alg.init = crypto_ccm_init_tfm;
     521                 :          0 :         inst->alg.exit = crypto_ccm_exit_tfm;
     522                 :          0 :         inst->alg.setkey = crypto_ccm_setkey;
     523                 :          0 :         inst->alg.setauthsize = crypto_ccm_setauthsize;
     524                 :          0 :         inst->alg.encrypt = crypto_ccm_encrypt;
     525                 :          0 :         inst->alg.decrypt = crypto_ccm_decrypt;
     526                 :            : 
     527                 :          0 :         inst->free = crypto_ccm_free;
     528                 :            : 
     529                 :          0 :         err = aead_register_instance(tmpl, inst);
     530         [ #  # ]:          0 :         if (err) {
     531                 :          0 : err_free_inst:
     532                 :          0 :                 crypto_ccm_free(inst);
     533                 :            :         }
     534                 :            :         return err;
     535                 :            : }
     536                 :            : 
     537                 :          0 : static int crypto_ccm_create(struct crypto_template *tmpl, struct rtattr **tb)
     538                 :            : {
     539                 :          0 :         const char *cipher_name;
     540                 :          0 :         char ctr_name[CRYPTO_MAX_ALG_NAME];
     541                 :          0 :         char mac_name[CRYPTO_MAX_ALG_NAME];
     542                 :            : 
     543                 :          0 :         cipher_name = crypto_attr_alg_name(tb[1]);
     544         [ #  # ]:          0 :         if (IS_ERR(cipher_name))
     545                 :          0 :                 return PTR_ERR(cipher_name);
     546                 :            : 
     547         [ #  # ]:          0 :         if (snprintf(ctr_name, CRYPTO_MAX_ALG_NAME, "ctr(%s)",
     548                 :            :                      cipher_name) >= CRYPTO_MAX_ALG_NAME)
     549                 :            :                 return -ENAMETOOLONG;
     550                 :            : 
     551         [ #  # ]:          0 :         if (snprintf(mac_name, CRYPTO_MAX_ALG_NAME, "cbcmac(%s)",
     552                 :            :                      cipher_name) >= CRYPTO_MAX_ALG_NAME)
     553                 :            :                 return -ENAMETOOLONG;
     554                 :            : 
     555                 :          0 :         return crypto_ccm_create_common(tmpl, tb, ctr_name, mac_name);
     556                 :            : }
     557                 :            : 
     558                 :          0 : static int crypto_ccm_base_create(struct crypto_template *tmpl,
     559                 :            :                                   struct rtattr **tb)
     560                 :            : {
     561                 :          0 :         const char *ctr_name;
     562                 :          0 :         const char *mac_name;
     563                 :            : 
     564                 :          0 :         ctr_name = crypto_attr_alg_name(tb[1]);
     565         [ #  # ]:          0 :         if (IS_ERR(ctr_name))
     566                 :          0 :                 return PTR_ERR(ctr_name);
     567                 :            : 
     568                 :          0 :         mac_name = crypto_attr_alg_name(tb[2]);
     569         [ #  # ]:          0 :         if (IS_ERR(mac_name))
     570                 :          0 :                 return PTR_ERR(mac_name);
     571                 :            : 
     572                 :          0 :         return crypto_ccm_create_common(tmpl, tb, ctr_name, mac_name);
     573                 :            : }
     574                 :            : 
     575                 :          0 : static int crypto_rfc4309_setkey(struct crypto_aead *parent, const u8 *key,
     576                 :            :                                  unsigned int keylen)
     577                 :            : {
     578         [ #  # ]:          0 :         struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(parent);
     579                 :          0 :         struct crypto_aead *child = ctx->child;
     580                 :            : 
     581         [ #  # ]:          0 :         if (keylen < 3)
     582                 :            :                 return -EINVAL;
     583                 :            : 
     584                 :          0 :         keylen -= 3;
     585                 :          0 :         memcpy(ctx->nonce, key + keylen, 3);
     586                 :            : 
     587                 :          0 :         crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK);
     588                 :          0 :         crypto_aead_set_flags(child, crypto_aead_get_flags(parent) &
     589                 :            :                                      CRYPTO_TFM_REQ_MASK);
     590                 :          0 :         return crypto_aead_setkey(child, key, keylen);
     591                 :            : }
     592                 :            : 
     593                 :          0 : static int crypto_rfc4309_setauthsize(struct crypto_aead *parent,
     594                 :            :                                       unsigned int authsize)
     595                 :            : {
     596         [ #  # ]:          0 :         struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(parent);
     597                 :            : 
     598         [ #  # ]:          0 :         switch (authsize) {
     599                 :            :         case 8:
     600                 :            :         case 12:
     601                 :            :         case 16:
     602                 :          0 :                 break;
     603                 :            :         default:
     604                 :            :                 return -EINVAL;
     605                 :            :         }
     606                 :            : 
     607                 :          0 :         return crypto_aead_setauthsize(ctx->child, authsize);
     608                 :            : }
     609                 :            : 
     610                 :          0 : static struct aead_request *crypto_rfc4309_crypt(struct aead_request *req)
     611                 :            : {
     612                 :          0 :         struct crypto_rfc4309_req_ctx *rctx = aead_request_ctx(req);
     613                 :          0 :         struct aead_request *subreq = &rctx->subreq;
     614                 :          0 :         struct crypto_aead *aead = crypto_aead_reqtfm(req);
     615                 :          0 :         struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(aead);
     616                 :          0 :         struct crypto_aead *child = ctx->child;
     617                 :          0 :         struct scatterlist *sg;
     618                 :          0 :         u8 *iv = PTR_ALIGN((u8 *)(subreq + 1) + crypto_aead_reqsize(child),
     619                 :            :                            crypto_aead_alignmask(child) + 1);
     620                 :            : 
     621                 :            :         /* L' */
     622                 :          0 :         iv[0] = 3;
     623                 :            : 
     624                 :          0 :         memcpy(iv + 1, ctx->nonce, 3);
     625                 :          0 :         memcpy(iv + 4, req->iv, 8);
     626                 :            : 
     627                 :          0 :         scatterwalk_map_and_copy(iv + 16, req->src, 0, req->assoclen - 8, 0);
     628                 :            : 
     629                 :          0 :         sg_init_table(rctx->src, 3);
     630                 :          0 :         sg_set_buf(rctx->src, iv + 16, req->assoclen - 8);
     631                 :          0 :         sg = scatterwalk_ffwd(rctx->src + 1, req->src, req->assoclen);
     632         [ #  # ]:          0 :         if (sg != rctx->src + 1)
     633                 :          0 :                 sg_chain(rctx->src, 2, sg);
     634                 :            : 
     635         [ #  # ]:          0 :         if (req->src != req->dst) {
     636                 :          0 :                 sg_init_table(rctx->dst, 3);
     637                 :          0 :                 sg_set_buf(rctx->dst, iv + 16, req->assoclen - 8);
     638                 :          0 :                 sg = scatterwalk_ffwd(rctx->dst + 1, req->dst, req->assoclen);
     639         [ #  # ]:          0 :                 if (sg != rctx->dst + 1)
     640                 :          0 :                         sg_chain(rctx->dst, 2, sg);
     641                 :            :         }
     642                 :            : 
     643         [ #  # ]:          0 :         aead_request_set_tfm(subreq, child);
     644         [ #  # ]:          0 :         aead_request_set_callback(subreq, req->base.flags, req->base.complete,
     645                 :            :                                   req->base.data);
     646                 :          0 :         aead_request_set_crypt(subreq, rctx->src,
     647         [ #  # ]:          0 :                                req->src == req->dst ? rctx->src : rctx->dst,
     648                 :            :                                req->cryptlen, iv);
     649                 :          0 :         aead_request_set_ad(subreq, req->assoclen - 8);
     650                 :            : 
     651                 :          0 :         return subreq;
     652                 :            : }
     653                 :            : 
     654                 :          0 : static int crypto_rfc4309_encrypt(struct aead_request *req)
     655                 :            : {
     656         [ #  # ]:          0 :         if (req->assoclen != 16 && req->assoclen != 20)
     657                 :            :                 return -EINVAL;
     658                 :            : 
     659                 :          0 :         req = crypto_rfc4309_crypt(req);
     660                 :            : 
     661                 :          0 :         return crypto_aead_encrypt(req);
     662                 :            : }
     663                 :            : 
     664                 :          0 : static int crypto_rfc4309_decrypt(struct aead_request *req)
     665                 :            : {
     666         [ #  # ]:          0 :         if (req->assoclen != 16 && req->assoclen != 20)
     667                 :            :                 return -EINVAL;
     668                 :            : 
     669                 :          0 :         req = crypto_rfc4309_crypt(req);
     670                 :            : 
     671                 :          0 :         return crypto_aead_decrypt(req);
     672                 :            : }
     673                 :            : 
     674                 :          0 : static int crypto_rfc4309_init_tfm(struct crypto_aead *tfm)
     675                 :            : {
     676                 :          0 :         struct aead_instance *inst = aead_alg_instance(tfm);
     677                 :          0 :         struct crypto_aead_spawn *spawn = aead_instance_ctx(inst);
     678                 :          0 :         struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(tfm);
     679                 :          0 :         struct crypto_aead *aead;
     680                 :          0 :         unsigned long align;
     681                 :            : 
     682                 :          0 :         aead = crypto_spawn_aead(spawn);
     683         [ #  # ]:          0 :         if (IS_ERR(aead))
     684                 :          0 :                 return PTR_ERR(aead);
     685                 :            : 
     686                 :          0 :         ctx->child = aead;
     687                 :            : 
     688                 :          0 :         align = crypto_aead_alignmask(aead);
     689                 :          0 :         align &= ~(crypto_tfm_ctx_alignment() - 1);
     690                 :          0 :         crypto_aead_set_reqsize(
     691                 :            :                 tfm,
     692                 :            :                 sizeof(struct crypto_rfc4309_req_ctx) +
     693                 :          0 :                 ALIGN(crypto_aead_reqsize(aead), crypto_tfm_ctx_alignment()) +
     694                 :            :                 align + 32);
     695                 :            : 
     696                 :          0 :         return 0;
     697                 :            : }
     698                 :            : 
     699                 :          0 : static void crypto_rfc4309_exit_tfm(struct crypto_aead *tfm)
     700                 :            : {
     701                 :          0 :         struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(tfm);
     702                 :            : 
     703                 :          0 :         crypto_free_aead(ctx->child);
     704                 :          0 : }
     705                 :            : 
     706                 :          0 : static void crypto_rfc4309_free(struct aead_instance *inst)
     707                 :            : {
     708                 :          0 :         crypto_drop_aead(aead_instance_ctx(inst));
     709                 :          0 :         kfree(inst);
     710                 :          0 : }
     711                 :            : 
     712                 :          0 : static int crypto_rfc4309_create(struct crypto_template *tmpl,
     713                 :            :                                  struct rtattr **tb)
     714                 :            : {
     715                 :          0 :         struct crypto_attr_type *algt;
     716                 :          0 :         u32 mask;
     717                 :          0 :         struct aead_instance *inst;
     718                 :          0 :         struct crypto_aead_spawn *spawn;
     719                 :          0 :         struct aead_alg *alg;
     720                 :          0 :         const char *ccm_name;
     721                 :          0 :         int err;
     722                 :            : 
     723                 :          0 :         algt = crypto_get_attr_type(tb);
     724         [ #  # ]:          0 :         if (IS_ERR(algt))
     725                 :          0 :                 return PTR_ERR(algt);
     726                 :            : 
     727         [ #  # ]:          0 :         if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
     728                 :            :                 return -EINVAL;
     729                 :            : 
     730                 :          0 :         mask = crypto_requires_sync(algt->type, algt->mask);
     731                 :            : 
     732                 :          0 :         ccm_name = crypto_attr_alg_name(tb[1]);
     733         [ #  # ]:          0 :         if (IS_ERR(ccm_name))
     734                 :          0 :                 return PTR_ERR(ccm_name);
     735                 :            : 
     736                 :          0 :         inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
     737         [ #  # ]:          0 :         if (!inst)
     738                 :            :                 return -ENOMEM;
     739                 :            : 
     740                 :          0 :         spawn = aead_instance_ctx(inst);
     741                 :          0 :         err = crypto_grab_aead(spawn, aead_crypto_instance(inst),
     742                 :            :                                ccm_name, 0, mask);
     743         [ #  # ]:          0 :         if (err)
     744                 :          0 :                 goto out_free_inst;
     745                 :            : 
     746         [ #  # ]:          0 :         alg = crypto_spawn_aead_alg(spawn);
     747                 :            : 
     748                 :          0 :         err = -EINVAL;
     749                 :            : 
     750                 :            :         /* We only support 16-byte blocks. */
     751         [ #  # ]:          0 :         if (crypto_aead_alg_ivsize(alg) != 16)
     752                 :          0 :                 goto out_drop_alg;
     753                 :            : 
     754                 :            :         /* Not a stream cipher? */
     755         [ #  # ]:          0 :         if (alg->base.cra_blocksize != 1)
     756                 :          0 :                 goto out_drop_alg;
     757                 :            : 
     758                 :          0 :         err = -ENAMETOOLONG;
     759                 :          0 :         if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
     760         [ #  # ]:          0 :                      "rfc4309(%s)", alg->base.cra_name) >=
     761                 :          0 :             CRYPTO_MAX_ALG_NAME ||
     762                 :          0 :             snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
     763         [ #  # ]:          0 :                      "rfc4309(%s)", alg->base.cra_driver_name) >=
     764                 :            :             CRYPTO_MAX_ALG_NAME)
     765                 :          0 :                 goto out_drop_alg;
     766                 :            : 
     767                 :          0 :         inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
     768                 :          0 :         inst->alg.base.cra_priority = alg->base.cra_priority;
     769                 :          0 :         inst->alg.base.cra_blocksize = 1;
     770                 :          0 :         inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
     771                 :            : 
     772                 :          0 :         inst->alg.ivsize = 8;
     773                 :          0 :         inst->alg.chunksize = crypto_aead_alg_chunksize(alg);
     774                 :          0 :         inst->alg.maxauthsize = 16;
     775                 :            : 
     776                 :          0 :         inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc4309_ctx);
     777                 :            : 
     778                 :          0 :         inst->alg.init = crypto_rfc4309_init_tfm;
     779                 :          0 :         inst->alg.exit = crypto_rfc4309_exit_tfm;
     780                 :            : 
     781                 :          0 :         inst->alg.setkey = crypto_rfc4309_setkey;
     782                 :          0 :         inst->alg.setauthsize = crypto_rfc4309_setauthsize;
     783                 :          0 :         inst->alg.encrypt = crypto_rfc4309_encrypt;
     784                 :          0 :         inst->alg.decrypt = crypto_rfc4309_decrypt;
     785                 :            : 
     786                 :          0 :         inst->free = crypto_rfc4309_free;
     787                 :            : 
     788                 :          0 :         err = aead_register_instance(tmpl, inst);
     789         [ #  # ]:          0 :         if (err)
     790                 :          0 :                 goto out_drop_alg;
     791                 :            : 
     792                 :          0 : out:
     793                 :            :         return err;
     794                 :            : 
     795                 :          0 : out_drop_alg:
     796                 :          0 :         crypto_drop_aead(spawn);
     797                 :          0 : out_free_inst:
     798                 :          0 :         kfree(inst);
     799                 :          0 :         goto out;
     800                 :            : }
     801                 :            : 
     802                 :          0 : static int crypto_cbcmac_digest_setkey(struct crypto_shash *parent,
     803                 :            :                                      const u8 *inkey, unsigned int keylen)
     804                 :            : {
     805                 :          0 :         struct cbcmac_tfm_ctx *ctx = crypto_shash_ctx(parent);
     806                 :            : 
     807                 :          0 :         return crypto_cipher_setkey(ctx->child, inkey, keylen);
     808                 :            : }
     809                 :            : 
     810                 :          0 : static int crypto_cbcmac_digest_init(struct shash_desc *pdesc)
     811                 :            : {
     812                 :          0 :         struct cbcmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
     813                 :          0 :         int bs = crypto_shash_digestsize(pdesc->tfm);
     814                 :          0 :         u8 *dg = (u8 *)ctx + crypto_shash_descsize(pdesc->tfm) - bs;
     815                 :            : 
     816                 :            :         ctx->len = 0;
     817                 :          0 :         memset(dg, 0, bs);
     818                 :            : 
     819                 :          0 :         return 0;
     820                 :            : }
     821                 :            : 
     822                 :          0 : static int crypto_cbcmac_digest_update(struct shash_desc *pdesc, const u8 *p,
     823                 :            :                                        unsigned int len)
     824                 :            : {
     825                 :          0 :         struct crypto_shash *parent = pdesc->tfm;
     826                 :          0 :         struct cbcmac_tfm_ctx *tctx = crypto_shash_ctx(parent);
     827                 :          0 :         struct cbcmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
     828                 :          0 :         struct crypto_cipher *tfm = tctx->child;
     829                 :          0 :         int bs = crypto_shash_digestsize(parent);
     830                 :          0 :         u8 *dg = (u8 *)ctx + crypto_shash_descsize(parent) - bs;
     831                 :            : 
     832         [ #  # ]:          0 :         while (len > 0) {
     833                 :          0 :                 unsigned int l = min(len, bs - ctx->len);
     834                 :            : 
     835                 :          0 :                 crypto_xor(dg + ctx->len, p, l);
     836                 :          0 :                 ctx->len +=l;
     837                 :          0 :                 len -= l;
     838                 :          0 :                 p += l;
     839                 :            : 
     840         [ #  # ]:          0 :                 if (ctx->len == bs) {
     841                 :          0 :                         crypto_cipher_encrypt_one(tfm, dg, dg);
     842                 :          0 :                         ctx->len = 0;
     843                 :            :                 }
     844                 :            :         }
     845                 :            : 
     846                 :          0 :         return 0;
     847                 :            : }
     848                 :            : 
     849                 :          0 : static int crypto_cbcmac_digest_final(struct shash_desc *pdesc, u8 *out)
     850                 :            : {
     851                 :          0 :         struct crypto_shash *parent = pdesc->tfm;
     852         [ #  # ]:          0 :         struct cbcmac_tfm_ctx *tctx = crypto_shash_ctx(parent);
     853         [ #  # ]:          0 :         struct cbcmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
     854                 :          0 :         struct crypto_cipher *tfm = tctx->child;
     855         [ #  # ]:          0 :         int bs = crypto_shash_digestsize(parent);
     856         [ #  # ]:          0 :         u8 *dg = (u8 *)ctx + crypto_shash_descsize(parent) - bs;
     857                 :            : 
     858         [ #  # ]:          0 :         if (ctx->len)
     859                 :          0 :                 crypto_cipher_encrypt_one(tfm, dg, dg);
     860                 :            : 
     861                 :          0 :         memcpy(out, dg, bs);
     862                 :          0 :         return 0;
     863                 :            : }
     864                 :            : 
     865                 :          0 : static int cbcmac_init_tfm(struct crypto_tfm *tfm)
     866                 :            : {
     867                 :          0 :         struct crypto_cipher *cipher;
     868                 :          0 :         struct crypto_instance *inst = (void *)tfm->__crt_alg;
     869                 :          0 :         struct crypto_cipher_spawn *spawn = crypto_instance_ctx(inst);
     870                 :          0 :         struct cbcmac_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
     871                 :            : 
     872                 :          0 :         cipher = crypto_spawn_cipher(spawn);
     873         [ #  # ]:          0 :         if (IS_ERR(cipher))
     874                 :          0 :                 return PTR_ERR(cipher);
     875                 :            : 
     876                 :          0 :         ctx->child = cipher;
     877                 :            : 
     878                 :          0 :         return 0;
     879                 :            : };
     880                 :            : 
     881                 :          0 : static void cbcmac_exit_tfm(struct crypto_tfm *tfm)
     882                 :            : {
     883                 :          0 :         struct cbcmac_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
     884                 :          0 :         crypto_free_cipher(ctx->child);
     885                 :          0 : }
     886                 :            : 
     887                 :          0 : static int cbcmac_create(struct crypto_template *tmpl, struct rtattr **tb)
     888                 :            : {
     889                 :          0 :         struct shash_instance *inst;
     890                 :          0 :         struct crypto_cipher_spawn *spawn;
     891                 :          0 :         struct crypto_alg *alg;
     892                 :          0 :         int err;
     893                 :            : 
     894                 :          0 :         err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH);
     895         [ #  # ]:          0 :         if (err)
     896                 :            :                 return err;
     897                 :            : 
     898                 :          0 :         inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
     899         [ #  # ]:          0 :         if (!inst)
     900                 :            :                 return -ENOMEM;
     901                 :          0 :         spawn = shash_instance_ctx(inst);
     902                 :            : 
     903                 :          0 :         err = crypto_grab_cipher(spawn, shash_crypto_instance(inst),
     904                 :            :                                  crypto_attr_alg_name(tb[1]), 0, 0);
     905         [ #  # ]:          0 :         if (err)
     906                 :          0 :                 goto err_free_inst;
     907                 :          0 :         alg = crypto_spawn_cipher_alg(spawn);
     908                 :            : 
     909                 :          0 :         err = crypto_inst_setname(shash_crypto_instance(inst), tmpl->name, alg);
     910         [ #  # ]:          0 :         if (err)
     911                 :          0 :                 goto err_free_inst;
     912                 :            : 
     913                 :          0 :         inst->alg.base.cra_priority = alg->cra_priority;
     914                 :          0 :         inst->alg.base.cra_blocksize = 1;
     915                 :            : 
     916                 :          0 :         inst->alg.digestsize = alg->cra_blocksize;
     917                 :          0 :         inst->alg.descsize = ALIGN(sizeof(struct cbcmac_desc_ctx),
     918                 :          0 :                                    alg->cra_alignmask + 1) +
     919                 :            :                              alg->cra_blocksize;
     920                 :            : 
     921                 :          0 :         inst->alg.base.cra_ctxsize = sizeof(struct cbcmac_tfm_ctx);
     922                 :          0 :         inst->alg.base.cra_init = cbcmac_init_tfm;
     923                 :          0 :         inst->alg.base.cra_exit = cbcmac_exit_tfm;
     924                 :            : 
     925                 :          0 :         inst->alg.init = crypto_cbcmac_digest_init;
     926                 :          0 :         inst->alg.update = crypto_cbcmac_digest_update;
     927                 :          0 :         inst->alg.final = crypto_cbcmac_digest_final;
     928                 :          0 :         inst->alg.setkey = crypto_cbcmac_digest_setkey;
     929                 :            : 
     930                 :          0 :         inst->free = shash_free_singlespawn_instance;
     931                 :            : 
     932                 :          0 :         err = shash_register_instance(tmpl, inst);
     933         [ #  # ]:          0 :         if (err) {
     934                 :          0 : err_free_inst:
     935                 :          0 :                 shash_free_singlespawn_instance(inst);
     936                 :            :         }
     937                 :            :         return err;
     938                 :            : }
     939                 :            : 
     940                 :            : static struct crypto_template crypto_ccm_tmpls[] = {
     941                 :            :         {
     942                 :            :                 .name = "cbcmac",
     943                 :            :                 .create = cbcmac_create,
     944                 :            :                 .module = THIS_MODULE,
     945                 :            :         }, {
     946                 :            :                 .name = "ccm_base",
     947                 :            :                 .create = crypto_ccm_base_create,
     948                 :            :                 .module = THIS_MODULE,
     949                 :            :         }, {
     950                 :            :                 .name = "ccm",
     951                 :            :                 .create = crypto_ccm_create,
     952                 :            :                 .module = THIS_MODULE,
     953                 :            :         }, {
     954                 :            :                 .name = "rfc4309",
     955                 :            :                 .create = crypto_rfc4309_create,
     956                 :            :                 .module = THIS_MODULE,
     957                 :            :         },
     958                 :            : };
     959                 :            : 
     960                 :         78 : static int __init crypto_ccm_module_init(void)
     961                 :            : {
     962                 :         78 :         return crypto_register_templates(crypto_ccm_tmpls,
     963                 :            :                                          ARRAY_SIZE(crypto_ccm_tmpls));
     964                 :            : }
     965                 :            : 
     966                 :          0 : static void __exit crypto_ccm_module_exit(void)
     967                 :            : {
     968                 :          0 :         crypto_unregister_templates(crypto_ccm_tmpls,
     969                 :            :                                     ARRAY_SIZE(crypto_ccm_tmpls));
     970                 :          0 : }
     971                 :            : 
     972                 :            : subsys_initcall(crypto_ccm_module_init);
     973                 :            : module_exit(crypto_ccm_module_exit);
     974                 :            : 
     975                 :            : MODULE_LICENSE("GPL");
     976                 :            : MODULE_DESCRIPTION("Counter with CBC MAC");
     977                 :            : MODULE_ALIAS_CRYPTO("ccm_base");
     978                 :            : MODULE_ALIAS_CRYPTO("rfc4309");
     979                 :            : MODULE_ALIAS_CRYPTO("ccm");
     980                 :            : MODULE_ALIAS_CRYPTO("cbcmac");

Generated by: LCOV version 1.14