954 lines · c
1/* SPDX-License-Identifier: GPL-2.0-or-later */2/*3 * Hash: Hash algorithms under the crypto API4 * 5 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>6 */7 8#ifndef _CRYPTO_HASH_H9#define _CRYPTO_HASH_H10 11#include <linux/atomic.h>12#include <linux/crypto.h>13#include <linux/string.h>14 15struct crypto_ahash;16 17/**18 * DOC: Message Digest Algorithm Definitions19 *20 * These data structures define modular message digest algorithm21 * implementations, managed via crypto_register_ahash(),22 * crypto_register_shash(), crypto_unregister_ahash() and23 * crypto_unregister_shash().24 */25 26/*27 * struct hash_alg_common - define properties of message digest28 * @digestsize: Size of the result of the transformation. A buffer of this size29 * must be available to the @final and @finup calls, so they can30 * store the resulting hash into it. For various predefined sizes,31 * search include/crypto/ using32 * git grep _DIGEST_SIZE include/crypto.33 * @statesize: Size of the block for partial state of the transformation. A34 * buffer of this size must be passed to the @export function as it35 * will save the partial state of the transformation into it. On the36 * other side, the @import function will load the state from a37 * buffer of this size as well.38 * @base: Start of data structure of cipher algorithm. The common data39 * structure of crypto_alg contains information common to all ciphers.40 * The hash_alg_common data structure now adds the hash-specific41 * information.42 */43#define HASH_ALG_COMMON { \44 unsigned int digestsize; \45 unsigned int statesize; \46 \47 struct crypto_alg base; \48}49struct hash_alg_common HASH_ALG_COMMON;50 51struct ahash_request {52 struct crypto_async_request base;53 54 unsigned int nbytes;55 struct scatterlist *src;56 u8 *result;57 58 /* This field may only be used by the ahash API code. */59 void *priv;60 61 void *__ctx[] CRYPTO_MINALIGN_ATTR;62};63 64/**65 * struct ahash_alg - asynchronous message digest definition66 * @init: **[mandatory]** Initialize the transformation context. Intended only to initialize the67 * state of the HASH transformation at the beginning. This shall fill in68 * the internal structures used during the entire duration of the whole69 * transformation. No data processing happens at this point. Driver code70 * implementation must not use req->result.71 * @update: **[mandatory]** Push a chunk of data into the driver for transformation. This72 * function actually pushes blocks of data from upper layers into the73 * driver, which then passes those to the hardware as seen fit. This74 * function must not finalize the HASH transformation by calculating the75 * final message digest as this only adds more data into the76 * transformation. This function shall not modify the transformation77 * context, as this function may be called in parallel with the same78 * transformation object. Data processing can happen synchronously79 * [SHASH] or asynchronously [AHASH] at this point. Driver must not use80 * req->result.81 * @final: **[mandatory]** Retrieve result from the driver. This function finalizes the82 * transformation and retrieves the resulting hash from the driver and83 * pushes it back to upper layers. No data processing happens at this84 * point unless hardware requires it to finish the transformation85 * (then the data buffered by the device driver is processed).86 * @finup: **[optional]** Combination of @update and @final. This function is effectively a87 * combination of @update and @final calls issued in sequence. As some88 * hardware cannot do @update and @final separately, this callback was89 * added to allow such hardware to be used at least by IPsec. Data90 * processing can happen synchronously [SHASH] or asynchronously [AHASH]91 * at this point.92 * @digest: Combination of @init and @update and @final. This function93 * effectively behaves as the entire chain of operations, @init,94 * @update and @final issued in sequence. Just like @finup, this was95 * added for hardware which cannot do even the @finup, but can only do96 * the whole transformation in one run. Data processing can happen97 * synchronously [SHASH] or asynchronously [AHASH] at this point.98 * @setkey: Set optional key used by the hashing algorithm. Intended to push99 * optional key used by the hashing algorithm from upper layers into100 * the driver. This function can store the key in the transformation101 * context or can outright program it into the hardware. In the former102 * case, one must be careful to program the key into the hardware at103 * appropriate time and one must be careful that .setkey() can be104 * called multiple times during the existence of the transformation105 * object. Not all hashing algorithms do implement this function as it106 * is only needed for keyed message digests. SHAx/MDx/CRCx do NOT107 * implement this function. HMAC(MDx)/HMAC(SHAx)/CMAC(AES) do implement108 * this function. This function must be called before any other of the109 * @init, @update, @final, @finup, @digest is called. No data110 * processing happens at this point.111 * @export: Export partial state of the transformation. This function dumps the112 * entire state of the ongoing transformation into a provided block of113 * data so it can be @import 'ed back later on. This is useful in case114 * you want to save partial result of the transformation after115 * processing certain amount of data and reload this partial result116 * multiple times later on for multiple re-use. No data processing117 * happens at this point. Driver must not use req->result.118 * @import: Import partial state of the transformation. This function loads the119 * entire state of the ongoing transformation from a provided block of120 * data so the transformation can continue from this point onward. No121 * data processing happens at this point. Driver must not use122 * req->result.123 * @init_tfm: Initialize the cryptographic transformation object.124 * This function is called only once at the instantiation125 * time, right after the transformation context was126 * allocated. In case the cryptographic hardware has127 * some special requirements which need to be handled128 * by software, this function shall check for the precise129 * requirement of the transformation and put any software130 * fallbacks in place.131 * @exit_tfm: Deinitialize the cryptographic transformation object.132 * This is a counterpart to @init_tfm, used to remove133 * various changes set in @init_tfm.134 * @clone_tfm: Copy transform into new object, may allocate memory.135 * @halg: see struct hash_alg_common136 */137struct ahash_alg {138 int (*init)(struct ahash_request *req);139 int (*update)(struct ahash_request *req);140 int (*final)(struct ahash_request *req);141 int (*finup)(struct ahash_request *req);142 int (*digest)(struct ahash_request *req);143 int (*export)(struct ahash_request *req, void *out);144 int (*import)(struct ahash_request *req, const void *in);145 int (*setkey)(struct crypto_ahash *tfm, const u8 *key,146 unsigned int keylen);147 int (*init_tfm)(struct crypto_ahash *tfm);148 void (*exit_tfm)(struct crypto_ahash *tfm);149 int (*clone_tfm)(struct crypto_ahash *dst, struct crypto_ahash *src);150 151 struct hash_alg_common halg;152};153 154struct shash_desc {155 struct crypto_shash *tfm;156 void *__ctx[] __aligned(ARCH_SLAB_MINALIGN);157};158 159#define HASH_MAX_DIGESTSIZE 64160 161/*162 * Worst case is hmac(sha3-224-generic). Its context is a nested 'shash_desc'163 * containing a 'struct sha3_state'.164 */165#define HASH_MAX_DESCSIZE (sizeof(struct shash_desc) + 360)166 167#define SHASH_DESC_ON_STACK(shash, ctx) \168 char __##shash##_desc[sizeof(struct shash_desc) + HASH_MAX_DESCSIZE] \169 __aligned(__alignof__(struct shash_desc)); \170 struct shash_desc *shash = (struct shash_desc *)__##shash##_desc171 172/**173 * struct shash_alg - synchronous message digest definition174 * @init: see struct ahash_alg175 * @update: see struct ahash_alg176 * @final: see struct ahash_alg177 * @finup: see struct ahash_alg178 * @digest: see struct ahash_alg179 * @export: see struct ahash_alg180 * @import: see struct ahash_alg181 * @setkey: see struct ahash_alg182 * @init_tfm: Initialize the cryptographic transformation object.183 * This function is called only once at the instantiation184 * time, right after the transformation context was185 * allocated. In case the cryptographic hardware has186 * some special requirements which need to be handled187 * by software, this function shall check for the precise188 * requirement of the transformation and put any software189 * fallbacks in place.190 * @exit_tfm: Deinitialize the cryptographic transformation object.191 * This is a counterpart to @init_tfm, used to remove192 * various changes set in @init_tfm.193 * @clone_tfm: Copy transform into new object, may allocate memory.194 * @descsize: Size of the operational state for the message digest. This state195 * size is the memory size that needs to be allocated for196 * shash_desc.__ctx197 * @halg: see struct hash_alg_common198 * @HASH_ALG_COMMON: see struct hash_alg_common199 */200struct shash_alg {201 int (*init)(struct shash_desc *desc);202 int (*update)(struct shash_desc *desc, const u8 *data,203 unsigned int len);204 int (*final)(struct shash_desc *desc, u8 *out);205 int (*finup)(struct shash_desc *desc, const u8 *data,206 unsigned int len, u8 *out);207 int (*digest)(struct shash_desc *desc, const u8 *data,208 unsigned int len, u8 *out);209 int (*export)(struct shash_desc *desc, void *out);210 int (*import)(struct shash_desc *desc, const void *in);211 int (*setkey)(struct crypto_shash *tfm, const u8 *key,212 unsigned int keylen);213 int (*init_tfm)(struct crypto_shash *tfm);214 void (*exit_tfm)(struct crypto_shash *tfm);215 int (*clone_tfm)(struct crypto_shash *dst, struct crypto_shash *src);216 217 unsigned int descsize;218 219 union {220 struct HASH_ALG_COMMON;221 struct hash_alg_common halg;222 };223};224#undef HASH_ALG_COMMON225 226struct crypto_ahash {227 bool using_shash; /* Underlying algorithm is shash, not ahash */228 unsigned int statesize;229 unsigned int reqsize;230 struct crypto_tfm base;231};232 233struct crypto_shash {234 unsigned int descsize;235 struct crypto_tfm base;236};237 238/**239 * DOC: Asynchronous Message Digest API240 *241 * The asynchronous message digest API is used with the ciphers of type242 * CRYPTO_ALG_TYPE_AHASH (listed as type "ahash" in /proc/crypto)243 *244 * The asynchronous cipher operation discussion provided for the245 * CRYPTO_ALG_TYPE_SKCIPHER API applies here as well.246 */247 248static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)249{250 return container_of(tfm, struct crypto_ahash, base);251}252 253/**254 * crypto_alloc_ahash() - allocate ahash cipher handle255 * @alg_name: is the cra_name / name or cra_driver_name / driver name of the256 * ahash cipher257 * @type: specifies the type of the cipher258 * @mask: specifies the mask for the cipher259 *260 * Allocate a cipher handle for an ahash. The returned struct261 * crypto_ahash is the cipher handle that is required for any subsequent262 * API invocation for that ahash.263 *264 * Return: allocated cipher handle in case of success; IS_ERR() is true in case265 * of an error, PTR_ERR() returns the error code.266 */267struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,268 u32 mask);269 270struct crypto_ahash *crypto_clone_ahash(struct crypto_ahash *tfm);271 272static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)273{274 return &tfm->base;275}276 277/**278 * crypto_free_ahash() - zeroize and free the ahash handle279 * @tfm: cipher handle to be freed280 *281 * If @tfm is a NULL or error pointer, this function does nothing.282 */283static inline void crypto_free_ahash(struct crypto_ahash *tfm)284{285 crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm));286}287 288/**289 * crypto_has_ahash() - Search for the availability of an ahash.290 * @alg_name: is the cra_name / name or cra_driver_name / driver name of the291 * ahash292 * @type: specifies the type of the ahash293 * @mask: specifies the mask for the ahash294 *295 * Return: true when the ahash is known to the kernel crypto API; false296 * otherwise297 */298int crypto_has_ahash(const char *alg_name, u32 type, u32 mask);299 300static inline const char *crypto_ahash_alg_name(struct crypto_ahash *tfm)301{302 return crypto_tfm_alg_name(crypto_ahash_tfm(tfm));303}304 305static inline const char *crypto_ahash_driver_name(struct crypto_ahash *tfm)306{307 return crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));308}309 310/**311 * crypto_ahash_blocksize() - obtain block size for cipher312 * @tfm: cipher handle313 *314 * The block size for the message digest cipher referenced with the cipher315 * handle is returned.316 *317 * Return: block size of cipher318 */319static inline unsigned int crypto_ahash_blocksize(struct crypto_ahash *tfm)320{321 return crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));322}323 324static inline struct hash_alg_common *__crypto_hash_alg_common(325 struct crypto_alg *alg)326{327 return container_of(alg, struct hash_alg_common, base);328}329 330static inline struct hash_alg_common *crypto_hash_alg_common(331 struct crypto_ahash *tfm)332{333 return __crypto_hash_alg_common(crypto_ahash_tfm(tfm)->__crt_alg);334}335 336/**337 * crypto_ahash_digestsize() - obtain message digest size338 * @tfm: cipher handle339 *340 * The size for the message digest created by the message digest cipher341 * referenced with the cipher handle is returned.342 *343 *344 * Return: message digest size of cipher345 */346static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)347{348 return crypto_hash_alg_common(tfm)->digestsize;349}350 351/**352 * crypto_ahash_statesize() - obtain size of the ahash state353 * @tfm: cipher handle354 *355 * Return the size of the ahash state. With the crypto_ahash_export()356 * function, the caller can export the state into a buffer whose size is357 * defined with this function.358 *359 * Return: size of the ahash state360 */361static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm)362{363 return tfm->statesize;364}365 366static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)367{368 return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));369}370 371static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)372{373 crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);374}375 376static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)377{378 crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);379}380 381/**382 * crypto_ahash_reqtfm() - obtain cipher handle from request383 * @req: asynchronous request handle that contains the reference to the ahash384 * cipher handle385 *386 * Return the ahash cipher handle that is registered with the asynchronous387 * request handle ahash_request.388 *389 * Return: ahash cipher handle390 */391static inline struct crypto_ahash *crypto_ahash_reqtfm(392 struct ahash_request *req)393{394 return __crypto_ahash_cast(req->base.tfm);395}396 397/**398 * crypto_ahash_reqsize() - obtain size of the request data structure399 * @tfm: cipher handle400 *401 * Return: size of the request data402 */403static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)404{405 return tfm->reqsize;406}407 408static inline void *ahash_request_ctx(struct ahash_request *req)409{410 return req->__ctx;411}412 413/**414 * crypto_ahash_setkey - set key for cipher handle415 * @tfm: cipher handle416 * @key: buffer holding the key417 * @keylen: length of the key in bytes418 *419 * The caller provided key is set for the ahash cipher. The cipher420 * handle must point to a keyed hash in order for this function to succeed.421 *422 * Return: 0 if the setting of the key was successful; < 0 if an error occurred423 */424int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,425 unsigned int keylen);426 427/**428 * crypto_ahash_finup() - update and finalize message digest429 * @req: reference to the ahash_request handle that holds all information430 * needed to perform the cipher operation431 *432 * This function is a "short-hand" for the function calls of433 * crypto_ahash_update and crypto_ahash_final. The parameters have the same434 * meaning as discussed for those separate functions.435 *436 * Return: see crypto_ahash_final()437 */438int crypto_ahash_finup(struct ahash_request *req);439 440/**441 * crypto_ahash_final() - calculate message digest442 * @req: reference to the ahash_request handle that holds all information443 * needed to perform the cipher operation444 *445 * Finalize the message digest operation and create the message digest446 * based on all data added to the cipher handle. The message digest is placed447 * into the output buffer registered with the ahash_request handle.448 *449 * Return:450 * 0 if the message digest was successfully calculated;451 * -EINPROGRESS if data is fed into hardware (DMA) or queued for later;452 * -EBUSY if queue is full and request should be resubmitted later;453 * other < 0 if an error occurred454 */455int crypto_ahash_final(struct ahash_request *req);456 457/**458 * crypto_ahash_digest() - calculate message digest for a buffer459 * @req: reference to the ahash_request handle that holds all information460 * needed to perform the cipher operation461 *462 * This function is a "short-hand" for the function calls of crypto_ahash_init,463 * crypto_ahash_update and crypto_ahash_final. The parameters have the same464 * meaning as discussed for those separate three functions.465 *466 * Return: see crypto_ahash_final()467 */468int crypto_ahash_digest(struct ahash_request *req);469 470/**471 * crypto_ahash_export() - extract current message digest state472 * @req: reference to the ahash_request handle whose state is exported473 * @out: output buffer of sufficient size that can hold the hash state474 *475 * This function exports the hash state of the ahash_request handle into the476 * caller-allocated output buffer out which must have sufficient size (e.g. by477 * calling crypto_ahash_statesize()).478 *479 * Return: 0 if the export was successful; < 0 if an error occurred480 */481int crypto_ahash_export(struct ahash_request *req, void *out);482 483/**484 * crypto_ahash_import() - import message digest state485 * @req: reference to ahash_request handle the state is imported into486 * @in: buffer holding the state487 *488 * This function imports the hash state into the ahash_request handle from the489 * input buffer. That buffer should have been generated with the490 * crypto_ahash_export function.491 *492 * Return: 0 if the import was successful; < 0 if an error occurred493 */494int crypto_ahash_import(struct ahash_request *req, const void *in);495 496/**497 * crypto_ahash_init() - (re)initialize message digest handle498 * @req: ahash_request handle that already is initialized with all necessary499 * data using the ahash_request_* API functions500 *501 * The call (re-)initializes the message digest referenced by the ahash_request502 * handle. Any potentially existing state created by previous operations is503 * discarded.504 *505 * Return: see crypto_ahash_final()506 */507int crypto_ahash_init(struct ahash_request *req);508 509/**510 * crypto_ahash_update() - add data to message digest for processing511 * @req: ahash_request handle that was previously initialized with the512 * crypto_ahash_init call.513 *514 * Updates the message digest state of the &ahash_request handle. The input data515 * is pointed to by the scatter/gather list registered in the &ahash_request516 * handle517 *518 * Return: see crypto_ahash_final()519 */520int crypto_ahash_update(struct ahash_request *req);521 522/**523 * DOC: Asynchronous Hash Request Handle524 *525 * The &ahash_request data structure contains all pointers to data526 * required for the asynchronous cipher operation. This includes the cipher527 * handle (which can be used by multiple &ahash_request instances), pointer528 * to plaintext and the message digest output buffer, asynchronous callback529 * function, etc. It acts as a handle to the ahash_request_* API calls in a530 * similar way as ahash handle to the crypto_ahash_* API calls.531 */532 533/**534 * ahash_request_set_tfm() - update cipher handle reference in request535 * @req: request handle to be modified536 * @tfm: cipher handle that shall be added to the request handle537 *538 * Allow the caller to replace the existing ahash handle in the request539 * data structure with a different one.540 */541static inline void ahash_request_set_tfm(struct ahash_request *req,542 struct crypto_ahash *tfm)543{544 req->base.tfm = crypto_ahash_tfm(tfm);545}546 547/**548 * ahash_request_alloc() - allocate request data structure549 * @tfm: cipher handle to be registered with the request550 * @gfp: memory allocation flag that is handed to kmalloc by the API call.551 *552 * Allocate the request data structure that must be used with the ahash553 * message digest API calls. During554 * the allocation, the provided ahash handle555 * is registered in the request data structure.556 *557 * Return: allocated request handle in case of success, or NULL if out of memory558 */559static inline struct ahash_request *ahash_request_alloc_noprof(560 struct crypto_ahash *tfm, gfp_t gfp)561{562 struct ahash_request *req;563 564 req = kmalloc_noprof(sizeof(struct ahash_request) +565 crypto_ahash_reqsize(tfm), gfp);566 567 if (likely(req))568 ahash_request_set_tfm(req, tfm);569 570 return req;571}572#define ahash_request_alloc(...) alloc_hooks(ahash_request_alloc_noprof(__VA_ARGS__))573 574/**575 * ahash_request_free() - zeroize and free the request data structure576 * @req: request data structure cipher handle to be freed577 */578static inline void ahash_request_free(struct ahash_request *req)579{580 kfree_sensitive(req);581}582 583static inline void ahash_request_zero(struct ahash_request *req)584{585 memzero_explicit(req, sizeof(*req) +586 crypto_ahash_reqsize(crypto_ahash_reqtfm(req)));587}588 589static inline struct ahash_request *ahash_request_cast(590 struct crypto_async_request *req)591{592 return container_of(req, struct ahash_request, base);593}594 595/**596 * ahash_request_set_callback() - set asynchronous callback function597 * @req: request handle598 * @flags: specify zero or an ORing of the flags599 * CRYPTO_TFM_REQ_MAY_BACKLOG the request queue may back log and600 * increase the wait queue beyond the initial maximum size;601 * CRYPTO_TFM_REQ_MAY_SLEEP the request processing may sleep602 * @compl: callback function pointer to be registered with the request handle603 * @data: The data pointer refers to memory that is not used by the kernel604 * crypto API, but provided to the callback function for it to use. Here,605 * the caller can provide a reference to memory the callback function can606 * operate on. As the callback function is invoked asynchronously to the607 * related functionality, it may need to access data structures of the608 * related functionality which can be referenced using this pointer. The609 * callback function can access the memory via the "data" field in the610 * &crypto_async_request data structure provided to the callback function.611 *612 * This function allows setting the callback function that is triggered once613 * the cipher operation completes.614 *615 * The callback function is registered with the &ahash_request handle and616 * must comply with the following template::617 *618 * void callback_function(struct crypto_async_request *req, int error)619 */620static inline void ahash_request_set_callback(struct ahash_request *req,621 u32 flags,622 crypto_completion_t compl,623 void *data)624{625 req->base.complete = compl;626 req->base.data = data;627 req->base.flags = flags;628}629 630/**631 * ahash_request_set_crypt() - set data buffers632 * @req: ahash_request handle to be updated633 * @src: source scatter/gather list634 * @result: buffer that is filled with the message digest -- the caller must635 * ensure that the buffer has sufficient space by, for example, calling636 * crypto_ahash_digestsize()637 * @nbytes: number of bytes to process from the source scatter/gather list638 *639 * By using this call, the caller references the source scatter/gather list.640 * The source scatter/gather list points to the data the message digest is to641 * be calculated for.642 */643static inline void ahash_request_set_crypt(struct ahash_request *req,644 struct scatterlist *src, u8 *result,645 unsigned int nbytes)646{647 req->src = src;648 req->nbytes = nbytes;649 req->result = result;650}651 652/**653 * DOC: Synchronous Message Digest API654 *655 * The synchronous message digest API is used with the ciphers of type656 * CRYPTO_ALG_TYPE_SHASH (listed as type "shash" in /proc/crypto)657 *658 * The message digest API is able to maintain state information for the659 * caller.660 *661 * The synchronous message digest API can store user-related context in its662 * shash_desc request data structure.663 */664 665/**666 * crypto_alloc_shash() - allocate message digest handle667 * @alg_name: is the cra_name / name or cra_driver_name / driver name of the668 * message digest cipher669 * @type: specifies the type of the cipher670 * @mask: specifies the mask for the cipher671 *672 * Allocate a cipher handle for a message digest. The returned &struct673 * crypto_shash is the cipher handle that is required for any subsequent674 * API invocation for that message digest.675 *676 * Return: allocated cipher handle in case of success; IS_ERR() is true in case677 * of an error, PTR_ERR() returns the error code.678 */679struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,680 u32 mask);681 682struct crypto_shash *crypto_clone_shash(struct crypto_shash *tfm);683 684int crypto_has_shash(const char *alg_name, u32 type, u32 mask);685 686static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)687{688 return &tfm->base;689}690 691/**692 * crypto_free_shash() - zeroize and free the message digest handle693 * @tfm: cipher handle to be freed694 *695 * If @tfm is a NULL or error pointer, this function does nothing.696 */697static inline void crypto_free_shash(struct crypto_shash *tfm)698{699 crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));700}701 702static inline const char *crypto_shash_alg_name(struct crypto_shash *tfm)703{704 return crypto_tfm_alg_name(crypto_shash_tfm(tfm));705}706 707static inline const char *crypto_shash_driver_name(struct crypto_shash *tfm)708{709 return crypto_tfm_alg_driver_name(crypto_shash_tfm(tfm));710}711 712/**713 * crypto_shash_blocksize() - obtain block size for cipher714 * @tfm: cipher handle715 *716 * The block size for the message digest cipher referenced with the cipher717 * handle is returned.718 *719 * Return: block size of cipher720 */721static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)722{723 return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));724}725 726static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)727{728 return container_of(alg, struct shash_alg, base);729}730 731static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)732{733 return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);734}735 736/**737 * crypto_shash_digestsize() - obtain message digest size738 * @tfm: cipher handle739 *740 * The size for the message digest created by the message digest cipher741 * referenced with the cipher handle is returned.742 *743 * Return: digest size of cipher744 */745static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)746{747 return crypto_shash_alg(tfm)->digestsize;748}749 750static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)751{752 return crypto_shash_alg(tfm)->statesize;753}754 755static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)756{757 return crypto_tfm_get_flags(crypto_shash_tfm(tfm));758}759 760static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)761{762 crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);763}764 765static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)766{767 crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);768}769 770/**771 * crypto_shash_descsize() - obtain the operational state size772 * @tfm: cipher handle773 *774 * The size of the operational state the cipher needs during operation is775 * returned for the hash referenced with the cipher handle. This size is776 * required to calculate the memory requirements to allow the caller allocating777 * sufficient memory for operational state.778 *779 * The operational state is defined with struct shash_desc where the size of780 * that data structure is to be calculated as781 * sizeof(struct shash_desc) + crypto_shash_descsize(alg)782 *783 * Return: size of the operational state784 */785static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)786{787 return tfm->descsize;788}789 790static inline void *shash_desc_ctx(struct shash_desc *desc)791{792 return desc->__ctx;793}794 795/**796 * crypto_shash_setkey() - set key for message digest797 * @tfm: cipher handle798 * @key: buffer holding the key799 * @keylen: length of the key in bytes800 *801 * The caller provided key is set for the keyed message digest cipher. The802 * cipher handle must point to a keyed message digest cipher in order for this803 * function to succeed.804 *805 * Context: Any context.806 * Return: 0 if the setting of the key was successful; < 0 if an error occurred807 */808int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,809 unsigned int keylen);810 811/**812 * crypto_shash_digest() - calculate message digest for buffer813 * @desc: see crypto_shash_final()814 * @data: see crypto_shash_update()815 * @len: see crypto_shash_update()816 * @out: see crypto_shash_final()817 *818 * This function is a "short-hand" for the function calls of crypto_shash_init,819 * crypto_shash_update and crypto_shash_final. The parameters have the same820 * meaning as discussed for those separate three functions.821 *822 * Context: Any context.823 * Return: 0 if the message digest creation was successful; < 0 if an error824 * occurred825 */826int crypto_shash_digest(struct shash_desc *desc, const u8 *data,827 unsigned int len, u8 *out);828 829/**830 * crypto_shash_tfm_digest() - calculate message digest for buffer831 * @tfm: hash transformation object832 * @data: see crypto_shash_update()833 * @len: see crypto_shash_update()834 * @out: see crypto_shash_final()835 *836 * This is a simplified version of crypto_shash_digest() for users who don't837 * want to allocate their own hash descriptor (shash_desc). Instead,838 * crypto_shash_tfm_digest() takes a hash transformation object (crypto_shash)839 * directly, and it allocates a hash descriptor on the stack internally.840 * Note that this stack allocation may be fairly large.841 *842 * Context: Any context.843 * Return: 0 on success; < 0 if an error occurred.844 */845int crypto_shash_tfm_digest(struct crypto_shash *tfm, const u8 *data,846 unsigned int len, u8 *out);847 848/**849 * crypto_shash_export() - extract operational state for message digest850 * @desc: reference to the operational state handle whose state is exported851 * @out: output buffer of sufficient size that can hold the hash state852 *853 * This function exports the hash state of the operational state handle into the854 * caller-allocated output buffer out which must have sufficient size (e.g. by855 * calling crypto_shash_descsize).856 *857 * Context: Any context.858 * Return: 0 if the export creation was successful; < 0 if an error occurred859 */860int crypto_shash_export(struct shash_desc *desc, void *out);861 862/**863 * crypto_shash_import() - import operational state864 * @desc: reference to the operational state handle the state imported into865 * @in: buffer holding the state866 *867 * This function imports the hash state into the operational state handle from868 * the input buffer. That buffer should have been generated with the869 * crypto_ahash_export function.870 *871 * Context: Any context.872 * Return: 0 if the import was successful; < 0 if an error occurred873 */874int crypto_shash_import(struct shash_desc *desc, const void *in);875 876/**877 * crypto_shash_init() - (re)initialize message digest878 * @desc: operational state handle that is already filled879 *880 * The call (re-)initializes the message digest referenced by the881 * operational state handle. Any potentially existing state created by882 * previous operations is discarded.883 *884 * Context: Any context.885 * Return: 0 if the message digest initialization was successful; < 0 if an886 * error occurred887 */888static inline int crypto_shash_init(struct shash_desc *desc)889{890 struct crypto_shash *tfm = desc->tfm;891 892 if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)893 return -ENOKEY;894 895 return crypto_shash_alg(tfm)->init(desc);896}897 898/**899 * crypto_shash_update() - add data to message digest for processing900 * @desc: operational state handle that is already initialized901 * @data: input data to be added to the message digest902 * @len: length of the input data903 *904 * Updates the message digest state of the operational state handle.905 *906 * Context: Any context.907 * Return: 0 if the message digest update was successful; < 0 if an error908 * occurred909 */910int crypto_shash_update(struct shash_desc *desc, const u8 *data,911 unsigned int len);912 913/**914 * crypto_shash_final() - calculate message digest915 * @desc: operational state handle that is already filled with data916 * @out: output buffer filled with the message digest917 *918 * Finalize the message digest operation and create the message digest919 * based on all data added to the cipher handle. The message digest is placed920 * into the output buffer. The caller must ensure that the output buffer is921 * large enough by using crypto_shash_digestsize.922 *923 * Context: Any context.924 * Return: 0 if the message digest creation was successful; < 0 if an error925 * occurred926 */927int crypto_shash_final(struct shash_desc *desc, u8 *out);928 929/**930 * crypto_shash_finup() - calculate message digest of buffer931 * @desc: see crypto_shash_final()932 * @data: see crypto_shash_update()933 * @len: see crypto_shash_update()934 * @out: see crypto_shash_final()935 *936 * This function is a "short-hand" for the function calls of937 * crypto_shash_update and crypto_shash_final. The parameters have the same938 * meaning as discussed for those separate functions.939 *940 * Context: Any context.941 * Return: 0 if the message digest creation was successful; < 0 if an error942 * occurred943 */944int crypto_shash_finup(struct shash_desc *desc, const u8 *data,945 unsigned int len, u8 *out);946 947static inline void shash_desc_zero(struct shash_desc *desc)948{949 memzero_explicit(desc,950 sizeof(*desc) + crypto_shash_descsize(desc->tfm));951}952 953#endif /* _CRYPTO_HASH_H */954