Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0-or-later */
       2                 :            : /*
       3                 :            :  * Symmetric key ciphers.
       4                 :            :  * 
       5                 :            :  * Copyright (c) 2007-2015 Herbert Xu <herbert@gondor.apana.org.au>
       6                 :            :  */
       7                 :            : 
       8                 :            : #ifndef _CRYPTO_SKCIPHER_H
       9                 :            : #define _CRYPTO_SKCIPHER_H
      10                 :            : 
      11                 :            : #include <linux/crypto.h>
      12                 :            : #include <linux/kernel.h>
      13                 :            : #include <linux/slab.h>
      14                 :            : 
      15                 :            : /**
      16                 :            :  *      struct skcipher_request - Symmetric key cipher request
      17                 :            :  *      @cryptlen: Number of bytes to encrypt or decrypt
      18                 :            :  *      @iv: Initialisation Vector
      19                 :            :  *      @src: Source SG list
      20                 :            :  *      @dst: Destination SG list
      21                 :            :  *      @base: Underlying async request request
      22                 :            :  *      @__ctx: Start of private context data
      23                 :            :  */
      24                 :            : struct skcipher_request {
      25                 :            :         unsigned int cryptlen;
      26                 :            : 
      27                 :            :         u8 *iv;
      28                 :            : 
      29                 :            :         struct scatterlist *src;
      30                 :            :         struct scatterlist *dst;
      31                 :            : 
      32                 :            :         struct crypto_async_request base;
      33                 :            : 
      34                 :            :         void *__ctx[] CRYPTO_MINALIGN_ATTR;
      35                 :            : };
      36                 :            : 
      37                 :            : struct crypto_skcipher {
      38                 :            :         int (*setkey)(struct crypto_skcipher *tfm, const u8 *key,
      39                 :            :                       unsigned int keylen);
      40                 :            :         int (*encrypt)(struct skcipher_request *req);
      41                 :            :         int (*decrypt)(struct skcipher_request *req);
      42                 :            : 
      43                 :            :         unsigned int ivsize;
      44                 :            :         unsigned int reqsize;
      45                 :            :         unsigned int keysize;
      46                 :            : 
      47                 :            :         struct crypto_tfm base;
      48                 :            : };
      49                 :            : 
      50                 :            : struct crypto_sync_skcipher {
      51                 :            :         struct crypto_skcipher base;
      52                 :            : };
      53                 :            : 
      54                 :            : /**
      55                 :            :  * struct skcipher_alg - symmetric key cipher definition
      56                 :            :  * @min_keysize: Minimum key size supported by the transformation. This is the
      57                 :            :  *               smallest key length supported by this transformation algorithm.
      58                 :            :  *               This must be set to one of the pre-defined values as this is
      59                 :            :  *               not hardware specific. Possible values for this field can be
      60                 :            :  *               found via git grep "_MIN_KEY_SIZE" include/crypto/
      61                 :            :  * @max_keysize: Maximum key size supported by the transformation. This is the
      62                 :            :  *               largest key length supported by this transformation algorithm.
      63                 :            :  *               This must be set to one of the pre-defined values as this is
      64                 :            :  *               not hardware specific. Possible values for this field can be
      65                 :            :  *               found via git grep "_MAX_KEY_SIZE" include/crypto/
      66                 :            :  * @setkey: Set key for the transformation. This function is used to either
      67                 :            :  *          program a supplied key into the hardware or store the key in the
      68                 :            :  *          transformation context for programming it later. Note that this
      69                 :            :  *          function does modify the transformation context. This function can
      70                 :            :  *          be called multiple times during the existence of the transformation
      71                 :            :  *          object, so one must make sure the key is properly reprogrammed into
      72                 :            :  *          the hardware. This function is also responsible for checking the key
      73                 :            :  *          length for validity. In case a software fallback was put in place in
      74                 :            :  *          the @cra_init call, this function might need to use the fallback if
      75                 :            :  *          the algorithm doesn't support all of the key sizes.
      76                 :            :  * @encrypt: Encrypt a scatterlist of blocks. This function is used to encrypt
      77                 :            :  *           the supplied scatterlist containing the blocks of data. The crypto
      78                 :            :  *           API consumer is responsible for aligning the entries of the
      79                 :            :  *           scatterlist properly and making sure the chunks are correctly
      80                 :            :  *           sized. In case a software fallback was put in place in the
      81                 :            :  *           @cra_init call, this function might need to use the fallback if
      82                 :            :  *           the algorithm doesn't support all of the key sizes. In case the
      83                 :            :  *           key was stored in transformation context, the key might need to be
      84                 :            :  *           re-programmed into the hardware in this function. This function
      85                 :            :  *           shall not modify the transformation context, as this function may
      86                 :            :  *           be called in parallel with the same transformation object.
      87                 :            :  * @decrypt: Decrypt a single block. This is a reverse counterpart to @encrypt
      88                 :            :  *           and the conditions are exactly the same.
      89                 :            :  * @init: Initialize the cryptographic transformation object. This function
      90                 :            :  *        is used to initialize the cryptographic transformation object.
      91                 :            :  *        This function is called only once at the instantiation time, right
      92                 :            :  *        after the transformation context was allocated. In case the
      93                 :            :  *        cryptographic hardware has some special requirements which need to
      94                 :            :  *        be handled by software, this function shall check for the precise
      95                 :            :  *        requirement of the transformation and put any software fallbacks
      96                 :            :  *        in place.
      97                 :            :  * @exit: Deinitialize the cryptographic transformation object. This is a
      98                 :            :  *        counterpart to @init, used to remove various changes set in
      99                 :            :  *        @init.
     100                 :            :  * @ivsize: IV size applicable for transformation. The consumer must provide an
     101                 :            :  *          IV of exactly that size to perform the encrypt or decrypt operation.
     102                 :            :  * @chunksize: Equal to the block size except for stream ciphers such as
     103                 :            :  *             CTR where it is set to the underlying block size.
     104                 :            :  * @walksize: Equal to the chunk size except in cases where the algorithm is
     105                 :            :  *            considerably more efficient if it can operate on multiple chunks
     106                 :            :  *            in parallel. Should be a multiple of chunksize.
     107                 :            :  * @base: Definition of a generic crypto algorithm.
     108                 :            :  *
     109                 :            :  * All fields except @ivsize are mandatory and must be filled.
     110                 :            :  */
     111                 :            : struct skcipher_alg {
     112                 :            :         int (*setkey)(struct crypto_skcipher *tfm, const u8 *key,
     113                 :            :                       unsigned int keylen);
     114                 :            :         int (*encrypt)(struct skcipher_request *req);
     115                 :            :         int (*decrypt)(struct skcipher_request *req);
     116                 :            :         int (*init)(struct crypto_skcipher *tfm);
     117                 :            :         void (*exit)(struct crypto_skcipher *tfm);
     118                 :            : 
     119                 :            :         unsigned int min_keysize;
     120                 :            :         unsigned int max_keysize;
     121                 :            :         unsigned int ivsize;
     122                 :            :         unsigned int chunksize;
     123                 :            :         unsigned int walksize;
     124                 :            : 
     125                 :            :         struct crypto_alg base;
     126                 :            : };
     127                 :            : 
     128                 :            : #define MAX_SYNC_SKCIPHER_REQSIZE      384
     129                 :            : /*
     130                 :            :  * This performs a type-check against the "tfm" argument to make sure
     131                 :            :  * all users have the correct skcipher tfm for doing on-stack requests.
     132                 :            :  */
     133                 :            : #define SYNC_SKCIPHER_REQUEST_ON_STACK(name, tfm) \
     134                 :            :         char __##name##_desc[sizeof(struct skcipher_request) + \
     135                 :            :                              MAX_SYNC_SKCIPHER_REQSIZE + \
     136                 :            :                              (!(sizeof((struct crypto_sync_skcipher *)1 == \
     137                 :            :                                        (typeof(tfm))1))) \
     138                 :            :                             ] CRYPTO_MINALIGN_ATTR; \
     139                 :            :         struct skcipher_request *name = (void *)__##name##_desc
     140                 :            : 
     141                 :            : /**
     142                 :            :  * DOC: Symmetric Key Cipher API
     143                 :            :  *
     144                 :            :  * Symmetric key cipher API is used with the ciphers of type
     145                 :            :  * CRYPTO_ALG_TYPE_SKCIPHER (listed as type "skcipher" in /proc/crypto).
     146                 :            :  *
     147                 :            :  * Asynchronous cipher operations imply that the function invocation for a
     148                 :            :  * cipher request returns immediately before the completion of the operation.
     149                 :            :  * The cipher request is scheduled as a separate kernel thread and therefore
     150                 :            :  * load-balanced on the different CPUs via the process scheduler. To allow
     151                 :            :  * the kernel crypto API to inform the caller about the completion of a cipher
     152                 :            :  * request, the caller must provide a callback function. That function is
     153                 :            :  * invoked with the cipher handle when the request completes.
     154                 :            :  *
     155                 :            :  * To support the asynchronous operation, additional information than just the
     156                 :            :  * cipher handle must be supplied to the kernel crypto API. That additional
     157                 :            :  * information is given by filling in the skcipher_request data structure.
     158                 :            :  *
     159                 :            :  * For the symmetric key cipher API, the state is maintained with the tfm
     160                 :            :  * cipher handle. A single tfm can be used across multiple calls and in
     161                 :            :  * parallel. For asynchronous block cipher calls, context data supplied and
     162                 :            :  * only used by the caller can be referenced the request data structure in
     163                 :            :  * addition to the IV used for the cipher request. The maintenance of such
     164                 :            :  * state information would be important for a crypto driver implementer to
     165                 :            :  * have, because when calling the callback function upon completion of the
     166                 :            :  * cipher operation, that callback function may need some information about
     167                 :            :  * which operation just finished if it invoked multiple in parallel. This
     168                 :            :  * state information is unused by the kernel crypto API.
     169                 :            :  */
     170                 :            : 
     171                 :            : static inline struct crypto_skcipher *__crypto_skcipher_cast(
     172                 :            :         struct crypto_tfm *tfm)
     173                 :            : {
     174                 :          0 :         return container_of(tfm, struct crypto_skcipher, base);
     175                 :            : }
     176                 :            : 
     177                 :            : /**
     178                 :            :  * crypto_alloc_skcipher() - allocate symmetric key cipher handle
     179                 :            :  * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
     180                 :            :  *            skcipher cipher
     181                 :            :  * @type: specifies the type of the cipher
     182                 :            :  * @mask: specifies the mask for the cipher
     183                 :            :  *
     184                 :            :  * Allocate a cipher handle for an skcipher. The returned struct
     185                 :            :  * crypto_skcipher is the cipher handle that is required for any subsequent
     186                 :            :  * API invocation for that skcipher.
     187                 :            :  *
     188                 :            :  * Return: allocated cipher handle in case of success; IS_ERR() is true in case
     189                 :            :  *         of an error, PTR_ERR() returns the error code.
     190                 :            :  */
     191                 :            : struct crypto_skcipher *crypto_alloc_skcipher(const char *alg_name,
     192                 :            :                                               u32 type, u32 mask);
     193                 :            : 
     194                 :            : struct crypto_sync_skcipher *crypto_alloc_sync_skcipher(const char *alg_name,
     195                 :            :                                               u32 type, u32 mask);
     196                 :            : 
     197                 :            : static inline struct crypto_tfm *crypto_skcipher_tfm(
     198                 :            :         struct crypto_skcipher *tfm)
     199                 :            : {
     200                 :          0 :         return &tfm->base;
     201                 :            : }
     202                 :            : 
     203                 :            : /**
     204                 :            :  * crypto_free_skcipher() - zeroize and free cipher handle
     205                 :            :  * @tfm: cipher handle to be freed
     206                 :            :  */
     207                 :            : static inline void crypto_free_skcipher(struct crypto_skcipher *tfm)
     208                 :            : {
     209                 :          0 :         crypto_destroy_tfm(tfm, crypto_skcipher_tfm(tfm));
     210                 :            : }
     211                 :            : 
     212                 :            : static inline void crypto_free_sync_skcipher(struct crypto_sync_skcipher *tfm)
     213                 :            : {
     214                 :          0 :         crypto_free_skcipher(&tfm->base);
     215                 :            : }
     216                 :            : 
     217                 :            : /**
     218                 :            :  * crypto_has_skcipher() - Search for the availability of an skcipher.
     219                 :            :  * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
     220                 :            :  *            skcipher
     221                 :            :  * @type: specifies the type of the cipher
     222                 :            :  * @mask: specifies the mask for the cipher
     223                 :            :  *
     224                 :            :  * Return: true when the skcipher is known to the kernel crypto API; false
     225                 :            :  *         otherwise
     226                 :            :  */
     227                 :            : static inline int crypto_has_skcipher(const char *alg_name, u32 type,
     228                 :            :                                         u32 mask)
     229                 :            : {
     230                 :          0 :         return crypto_has_alg(alg_name, crypto_skcipher_type(type),
     231                 :            :                               crypto_skcipher_mask(mask));
     232                 :            : }
     233                 :            : 
     234                 :            : /**
     235                 :            :  * crypto_has_skcipher2() - Search for the availability of an skcipher.
     236                 :            :  * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
     237                 :            :  *            skcipher
     238                 :            :  * @type: specifies the type of the skcipher
     239                 :            :  * @mask: specifies the mask for the skcipher
     240                 :            :  *
     241                 :            :  * Return: true when the skcipher is known to the kernel crypto API; false
     242                 :            :  *         otherwise
     243                 :            :  */
     244                 :            : int crypto_has_skcipher2(const char *alg_name, u32 type, u32 mask);
     245                 :            : 
     246                 :            : static inline const char *crypto_skcipher_driver_name(
     247                 :            :         struct crypto_skcipher *tfm)
     248                 :            : {
     249                 :            :         return crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
     250                 :            : }
     251                 :            : 
     252                 :            : static inline struct skcipher_alg *crypto_skcipher_alg(
     253                 :            :         struct crypto_skcipher *tfm)
     254                 :            : {
     255                 :          0 :         return container_of(crypto_skcipher_tfm(tfm)->__crt_alg,
     256                 :            :                             struct skcipher_alg, base);
     257                 :            : }
     258                 :            : 
     259                 :            : static inline unsigned int crypto_skcipher_alg_ivsize(struct skcipher_alg *alg)
     260                 :            : {
     261                 :          0 :         if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
     262                 :            :             CRYPTO_ALG_TYPE_BLKCIPHER)
     263                 :          0 :                 return alg->base.cra_blkcipher.ivsize;
     264                 :            : 
     265                 :          0 :         if (alg->base.cra_ablkcipher.encrypt)
     266                 :          0 :                 return alg->base.cra_ablkcipher.ivsize;
     267                 :            : 
     268                 :          0 :         return alg->ivsize;
     269                 :            : }
     270                 :            : 
     271                 :            : /**
     272                 :            :  * crypto_skcipher_ivsize() - obtain IV size
     273                 :            :  * @tfm: cipher handle
     274                 :            :  *
     275                 :            :  * The size of the IV for the skcipher referenced by the cipher handle is
     276                 :            :  * returned. This IV size may be zero if the cipher does not need an IV.
     277                 :            :  *
     278                 :            :  * Return: IV size in bytes
     279                 :            :  */
     280                 :            : static inline unsigned int crypto_skcipher_ivsize(struct crypto_skcipher *tfm)
     281                 :            : {
     282                 :          0 :         return tfm->ivsize;
     283                 :            : }
     284                 :            : 
     285                 :            : static inline unsigned int crypto_sync_skcipher_ivsize(
     286                 :            :         struct crypto_sync_skcipher *tfm)
     287                 :            : {
     288                 :            :         return crypto_skcipher_ivsize(&tfm->base);
     289                 :            : }
     290                 :            : 
     291                 :            : /**
     292                 :            :  * crypto_skcipher_blocksize() - obtain block size of cipher
     293                 :            :  * @tfm: cipher handle
     294                 :            :  *
     295                 :            :  * The block size for the skcipher referenced with the cipher handle is
     296                 :            :  * returned. The caller may use that information to allocate appropriate
     297                 :            :  * memory for the data returned by the encryption or decryption operation
     298                 :            :  *
     299                 :            :  * Return: block size of cipher
     300                 :            :  */
     301                 :            : static inline unsigned int crypto_skcipher_blocksize(
     302                 :            :         struct crypto_skcipher *tfm)
     303                 :            : {
     304                 :            :         return crypto_tfm_alg_blocksize(crypto_skcipher_tfm(tfm));
     305                 :            : }
     306                 :            : 
     307                 :            : static inline unsigned int crypto_skcipher_alg_chunksize(
     308                 :            :         struct skcipher_alg *alg)
     309                 :            : {
     310                 :          0 :         if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
     311                 :            :             CRYPTO_ALG_TYPE_BLKCIPHER)
     312                 :          0 :                 return alg->base.cra_blocksize;
     313                 :            : 
     314                 :          0 :         if (alg->base.cra_ablkcipher.encrypt)
     315                 :          0 :                 return alg->base.cra_blocksize;
     316                 :            : 
     317                 :          0 :         return alg->chunksize;
     318                 :            : }
     319                 :            : 
     320                 :            : /**
     321                 :            :  * crypto_skcipher_chunksize() - obtain chunk size
     322                 :            :  * @tfm: cipher handle
     323                 :            :  *
     324                 :            :  * The block size is set to one for ciphers such as CTR.  However,
     325                 :            :  * you still need to provide incremental updates in multiples of
     326                 :            :  * the underlying block size as the IV does not have sub-block
     327                 :            :  * granularity.  This is known in this API as the chunk size.
     328                 :            :  *
     329                 :            :  * Return: chunk size in bytes
     330                 :            :  */
     331                 :            : static inline unsigned int crypto_skcipher_chunksize(
     332                 :            :         struct crypto_skcipher *tfm)
     333                 :            : {
     334                 :            :         return crypto_skcipher_alg_chunksize(crypto_skcipher_alg(tfm));
     335                 :            : }
     336                 :            : 
     337                 :            : static inline unsigned int crypto_sync_skcipher_blocksize(
     338                 :            :         struct crypto_sync_skcipher *tfm)
     339                 :            : {
     340                 :            :         return crypto_skcipher_blocksize(&tfm->base);
     341                 :            : }
     342                 :            : 
     343                 :            : static inline unsigned int crypto_skcipher_alignmask(
     344                 :            :         struct crypto_skcipher *tfm)
     345                 :            : {
     346                 :            :         return crypto_tfm_alg_alignmask(crypto_skcipher_tfm(tfm));
     347                 :            : }
     348                 :            : 
     349                 :            : static inline u32 crypto_skcipher_get_flags(struct crypto_skcipher *tfm)
     350                 :            : {
     351                 :            :         return crypto_tfm_get_flags(crypto_skcipher_tfm(tfm));
     352                 :            : }
     353                 :            : 
     354                 :            : static inline void crypto_skcipher_set_flags(struct crypto_skcipher *tfm,
     355                 :            :                                                u32 flags)
     356                 :            : {
     357                 :            :         crypto_tfm_set_flags(crypto_skcipher_tfm(tfm), flags);
     358                 :            : }
     359                 :            : 
     360                 :            : static inline void crypto_skcipher_clear_flags(struct crypto_skcipher *tfm,
     361                 :            :                                                  u32 flags)
     362                 :            : {
     363                 :            :         crypto_tfm_clear_flags(crypto_skcipher_tfm(tfm), flags);
     364                 :            : }
     365                 :            : 
     366                 :            : static inline u32 crypto_sync_skcipher_get_flags(
     367                 :            :         struct crypto_sync_skcipher *tfm)
     368                 :            : {
     369                 :            :         return crypto_skcipher_get_flags(&tfm->base);
     370                 :            : }
     371                 :            : 
     372                 :            : static inline void crypto_sync_skcipher_set_flags(
     373                 :            :         struct crypto_sync_skcipher *tfm, u32 flags)
     374                 :            : {
     375                 :            :         crypto_skcipher_set_flags(&tfm->base, flags);
     376                 :            : }
     377                 :            : 
     378                 :            : static inline void crypto_sync_skcipher_clear_flags(
     379                 :            :         struct crypto_sync_skcipher *tfm, u32 flags)
     380                 :            : {
     381                 :            :         crypto_skcipher_clear_flags(&tfm->base, flags);
     382                 :            : }
     383                 :            : 
     384                 :            : /**
     385                 :            :  * crypto_skcipher_setkey() - set key for cipher
     386                 :            :  * @tfm: cipher handle
     387                 :            :  * @key: buffer holding the key
     388                 :            :  * @keylen: length of the key in bytes
     389                 :            :  *
     390                 :            :  * The caller provided key is set for the skcipher referenced by the cipher
     391                 :            :  * handle.
     392                 :            :  *
     393                 :            :  * Note, the key length determines the cipher type. Many block ciphers implement
     394                 :            :  * different cipher modes depending on the key size, such as AES-128 vs AES-192
     395                 :            :  * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
     396                 :            :  * is performed.
     397                 :            :  *
     398                 :            :  * Return: 0 if the setting of the key was successful; < 0 if an error occurred
     399                 :            :  */
     400                 :            : static inline int crypto_skcipher_setkey(struct crypto_skcipher *tfm,
     401                 :            :                                          const u8 *key, unsigned int keylen)
     402                 :            : {
     403                 :          0 :         return tfm->setkey(tfm, key, keylen);
     404                 :            : }
     405                 :            : 
     406                 :            : static inline int crypto_sync_skcipher_setkey(struct crypto_sync_skcipher *tfm,
     407                 :            :                                          const u8 *key, unsigned int keylen)
     408                 :            : {
     409                 :            :         return crypto_skcipher_setkey(&tfm->base, key, keylen);
     410                 :            : }
     411                 :            : 
     412                 :            : static inline unsigned int crypto_skcipher_default_keysize(
     413                 :            :         struct crypto_skcipher *tfm)
     414                 :            : {
     415                 :            :         return tfm->keysize;
     416                 :            : }
     417                 :            : 
     418                 :            : /**
     419                 :            :  * crypto_skcipher_reqtfm() - obtain cipher handle from request
     420                 :            :  * @req: skcipher_request out of which the cipher handle is to be obtained
     421                 :            :  *
     422                 :            :  * Return the crypto_skcipher handle when furnishing an skcipher_request
     423                 :            :  * data structure.
     424                 :            :  *
     425                 :            :  * Return: crypto_skcipher handle
     426                 :            :  */
     427                 :            : static inline struct crypto_skcipher *crypto_skcipher_reqtfm(
     428                 :            :         struct skcipher_request *req)
     429                 :            : {
     430                 :          0 :         return __crypto_skcipher_cast(req->base.tfm);
     431                 :            : }
     432                 :            : 
     433                 :            : static inline struct crypto_sync_skcipher *crypto_sync_skcipher_reqtfm(
     434                 :            :         struct skcipher_request *req)
     435                 :            : {
     436                 :            :         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
     437                 :            : 
     438                 :            :         return container_of(tfm, struct crypto_sync_skcipher, base);
     439                 :            : }
     440                 :            : 
     441                 :            : /**
     442                 :            :  * crypto_skcipher_encrypt() - encrypt plaintext
     443                 :            :  * @req: reference to the skcipher_request handle that holds all information
     444                 :            :  *       needed to perform the cipher operation
     445                 :            :  *
     446                 :            :  * Encrypt plaintext data using the skcipher_request handle. That data
     447                 :            :  * structure and how it is filled with data is discussed with the
     448                 :            :  * skcipher_request_* functions.
     449                 :            :  *
     450                 :            :  * Return: 0 if the cipher operation was successful; < 0 if an error occurred
     451                 :            :  */
     452                 :            : int crypto_skcipher_encrypt(struct skcipher_request *req);
     453                 :            : 
     454                 :            : /**
     455                 :            :  * crypto_skcipher_decrypt() - decrypt ciphertext
     456                 :            :  * @req: reference to the skcipher_request handle that holds all information
     457                 :            :  *       needed to perform the cipher operation
     458                 :            :  *
     459                 :            :  * Decrypt ciphertext data using the skcipher_request handle. That data
     460                 :            :  * structure and how it is filled with data is discussed with the
     461                 :            :  * skcipher_request_* functions.
     462                 :            :  *
     463                 :            :  * Return: 0 if the cipher operation was successful; < 0 if an error occurred
     464                 :            :  */
     465                 :            : int crypto_skcipher_decrypt(struct skcipher_request *req);
     466                 :            : 
     467                 :            : /**
     468                 :            :  * DOC: Symmetric Key Cipher Request Handle
     469                 :            :  *
     470                 :            :  * The skcipher_request data structure contains all pointers to data
     471                 :            :  * required for the symmetric key cipher operation. This includes the cipher
     472                 :            :  * handle (which can be used by multiple skcipher_request instances), pointer
     473                 :            :  * to plaintext and ciphertext, asynchronous callback function, etc. It acts
     474                 :            :  * as a handle to the skcipher_request_* API calls in a similar way as
     475                 :            :  * skcipher handle to the crypto_skcipher_* API calls.
     476                 :            :  */
     477                 :            : 
     478                 :            : /**
     479                 :            :  * crypto_skcipher_reqsize() - obtain size of the request data structure
     480                 :            :  * @tfm: cipher handle
     481                 :            :  *
     482                 :            :  * Return: number of bytes
     483                 :            :  */
     484                 :            : static inline unsigned int crypto_skcipher_reqsize(struct crypto_skcipher *tfm)
     485                 :            : {
     486                 :          0 :         return tfm->reqsize;
     487                 :            : }
     488                 :            : 
     489                 :            : /**
     490                 :            :  * skcipher_request_set_tfm() - update cipher handle reference in request
     491                 :            :  * @req: request handle to be modified
     492                 :            :  * @tfm: cipher handle that shall be added to the request handle
     493                 :            :  *
     494                 :            :  * Allow the caller to replace the existing skcipher handle in the request
     495                 :            :  * data structure with a different one.
     496                 :            :  */
     497                 :            : static inline void skcipher_request_set_tfm(struct skcipher_request *req,
     498                 :            :                                             struct crypto_skcipher *tfm)
     499                 :            : {
     500                 :          0 :         req->base.tfm = crypto_skcipher_tfm(tfm);
     501                 :            : }
     502                 :            : 
     503                 :            : static inline void skcipher_request_set_sync_tfm(struct skcipher_request *req,
     504                 :            :                                             struct crypto_sync_skcipher *tfm)
     505                 :            : {
     506                 :            :         skcipher_request_set_tfm(req, &tfm->base);
     507                 :            : }
     508                 :            : 
     509                 :            : static inline struct skcipher_request *skcipher_request_cast(
     510                 :            :         struct crypto_async_request *req)
     511                 :            : {
     512                 :            :         return container_of(req, struct skcipher_request, base);
     513                 :            : }
     514                 :            : 
     515                 :            : /**
     516                 :            :  * skcipher_request_alloc() - allocate request data structure
     517                 :            :  * @tfm: cipher handle to be registered with the request
     518                 :            :  * @gfp: memory allocation flag that is handed to kmalloc by the API call.
     519                 :            :  *
     520                 :            :  * Allocate the request data structure that must be used with the skcipher
     521                 :            :  * encrypt and decrypt API calls. During the allocation, the provided skcipher
     522                 :            :  * handle is registered in the request data structure.
     523                 :            :  *
     524                 :            :  * Return: allocated request handle in case of success, or NULL if out of memory
     525                 :            :  */
     526                 :          0 : static inline struct skcipher_request *skcipher_request_alloc(
     527                 :            :         struct crypto_skcipher *tfm, gfp_t gfp)
     528                 :            : {
     529                 :            :         struct skcipher_request *req;
     530                 :            : 
     531                 :          0 :         req = kmalloc(sizeof(struct skcipher_request) +
     532                 :            :                       crypto_skcipher_reqsize(tfm), gfp);
     533                 :            : 
     534                 :          0 :         if (likely(req))
     535                 :            :                 skcipher_request_set_tfm(req, tfm);
     536                 :            : 
     537                 :          0 :         return req;
     538                 :            : }
     539                 :            : 
     540                 :            : /**
     541                 :            :  * skcipher_request_free() - zeroize and free request data structure
     542                 :            :  * @req: request data structure cipher handle to be freed
     543                 :            :  */
     544                 :            : static inline void skcipher_request_free(struct skcipher_request *req)
     545                 :            : {
     546                 :          0 :         kzfree(req);
     547                 :            : }
     548                 :            : 
     549                 :            : static inline void skcipher_request_zero(struct skcipher_request *req)
     550                 :            : {
     551                 :            :         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
     552                 :            : 
     553                 :            :         memzero_explicit(req, sizeof(*req) + crypto_skcipher_reqsize(tfm));
     554                 :            : }
     555                 :            : 
     556                 :            : /**
     557                 :            :  * skcipher_request_set_callback() - set asynchronous callback function
     558                 :            :  * @req: request handle
     559                 :            :  * @flags: specify zero or an ORing of the flags
     560                 :            :  *         CRYPTO_TFM_REQ_MAY_BACKLOG the request queue may back log and
     561                 :            :  *         increase the wait queue beyond the initial maximum size;
     562                 :            :  *         CRYPTO_TFM_REQ_MAY_SLEEP the request processing may sleep
     563                 :            :  * @compl: callback function pointer to be registered with the request handle
     564                 :            :  * @data: The data pointer refers to memory that is not used by the kernel
     565                 :            :  *        crypto API, but provided to the callback function for it to use. Here,
     566                 :            :  *        the caller can provide a reference to memory the callback function can
     567                 :            :  *        operate on. As the callback function is invoked asynchronously to the
     568                 :            :  *        related functionality, it may need to access data structures of the
     569                 :            :  *        related functionality which can be referenced using this pointer. The
     570                 :            :  *        callback function can access the memory via the "data" field in the
     571                 :            :  *        crypto_async_request data structure provided to the callback function.
     572                 :            :  *
     573                 :            :  * This function allows setting the callback function that is triggered once the
     574                 :            :  * cipher operation completes.
     575                 :            :  *
     576                 :            :  * The callback function is registered with the skcipher_request handle and
     577                 :            :  * must comply with the following template::
     578                 :            :  *
     579                 :            :  *      void callback_function(struct crypto_async_request *req, int error)
     580                 :            :  */
     581                 :            : static inline void skcipher_request_set_callback(struct skcipher_request *req,
     582                 :            :                                                  u32 flags,
     583                 :            :                                                  crypto_completion_t compl,
     584                 :            :                                                  void *data)
     585                 :            : {
     586                 :          0 :         req->base.complete = compl;
     587                 :          0 :         req->base.data = data;
     588                 :          0 :         req->base.flags = flags;
     589                 :            : }
     590                 :            : 
     591                 :            : /**
     592                 :            :  * skcipher_request_set_crypt() - set data buffers
     593                 :            :  * @req: request handle
     594                 :            :  * @src: source scatter / gather list
     595                 :            :  * @dst: destination scatter / gather list
     596                 :            :  * @cryptlen: number of bytes to process from @src
     597                 :            :  * @iv: IV for the cipher operation which must comply with the IV size defined
     598                 :            :  *      by crypto_skcipher_ivsize
     599                 :            :  *
     600                 :            :  * This function allows setting of the source data and destination data
     601                 :            :  * scatter / gather lists.
     602                 :            :  *
     603                 :            :  * For encryption, the source is treated as the plaintext and the
     604                 :            :  * destination is the ciphertext. For a decryption operation, the use is
     605                 :            :  * reversed - the source is the ciphertext and the destination is the plaintext.
     606                 :            :  */
     607                 :            : static inline void skcipher_request_set_crypt(
     608                 :            :         struct skcipher_request *req,
     609                 :            :         struct scatterlist *src, struct scatterlist *dst,
     610                 :            :         unsigned int cryptlen, void *iv)
     611                 :            : {
     612                 :          0 :         req->src = src;
     613                 :          0 :         req->dst = dst;
     614                 :          0 :         req->cryptlen = cryptlen;
     615                 :          0 :         req->iv = iv;
     616                 :            : }
     617                 :            : 
     618                 :            : #endif  /* _CRYPTO_SKCIPHER_H */
     619                 :            :