/* * Scatterlist Cryptographic API. * * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> * Copyright (c) 2002 David S. Miller (davem@redhat.com) * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au> * * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no> * and Nettle, by Niels Möller. *  * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option)  * any later version. * */#ifndef _LINUX_CRYPTO_H#define _LINUX_CRYPTO_H #include <linux/atomic.h>#include <linux/kernel.h>#include <linux/list.h>#include <linux/bug.h>#include <linux/slab.h>#include <linux/string.h>#include <linux/uaccess.h> /* * Algorithm masks and types. */#define CRYPTO_ALG_TYPE_MASK		0x0000000f#define CRYPTO_ALG_TYPE_CIPHER		0x00000001#define CRYPTO_ALG_TYPE_COMPRESS	0x00000002#define CRYPTO_ALG_TYPE_AEAD		0x00000003#define CRYPTO_ALG_TYPE_BLKCIPHER	0x00000004#define CRYPTO_ALG_TYPE_ABLKCIPHER	0x00000005#define CRYPTO_ALG_TYPE_GIVCIPHER	0x00000006#define CRYPTO_ALG_TYPE_DIGEST		0x00000008#define CRYPTO_ALG_TYPE_HASH		0x00000008#define CRYPTO_ALG_TYPE_SHASH		0x00000009#define CRYPTO_ALG_TYPE_AHASH		0x0000000a#define CRYPTO_ALG_TYPE_RNG		0x0000000c#define CRYPTO_ALG_TYPE_PCOMPRESS	0x0000000f #define CRYPTO_ALG_TYPE_HASH_MASK	0x0000000e#define CRYPTO_ALG_TYPE_AHASH_MASK	0x0000000c#define CRYPTO_ALG_TYPE_BLKCIPHER_MASK	0x0000000c #define CRYPTO_ALG_LARVAL		0x00000010#define CRYPTO_ALG_DEAD			0x00000020#define CRYPTO_ALG_DYING		0x00000040#define CRYPTO_ALG_ASYNC		0x00000080 /* * Set this bit if and only if the algorithm requires another algorithm of * the same type to handle corner cases. */#define CRYPTO_ALG_NEED_FALLBACK	0x00000100 /* * This bit is set for symmetric key ciphers that have already been wrapped * with a generic IV generator to prevent them from being wrapped again. */#define CRYPTO_ALG_GENIV		0x00000200 /* * Set if the algorithm has passed automated run-time testing.  Note that * if there is no run-time testing for a given algorithm it is considered * to have passed. */ #define CRYPTO_ALG_TESTED		0x00000400 /* * Set if the algorithm is an instance that is build from templates. */#define CRYPTO_ALG_INSTANCE		0x00000800 /* Set this bit if the algorithm provided is hardware accelerated but * not available to userspace via instruction set or so. */#define CRYPTO_ALG_KERN_DRIVER_ONLY	0x00001000 /* * Transform masks and values (for crt_flags). */#define CRYPTO_TFM_REQ_MASK		0x000fff00#define CRYPTO_TFM_RES_MASK		0xfff00000 #define CRYPTO_TFM_REQ_WEAK_KEY		0x00000100#define CRYPTO_TFM_REQ_MAY_SLEEP	0x00000200#define CRYPTO_TFM_REQ_MAY_BACKLOG	0x00000400#define CRYPTO_TFM_RES_WEAK_KEY		0x00100000#define CRYPTO_TFM_RES_BAD_KEY_LEN   	0x00200000#define CRYPTO_TFM_RES_BAD_KEY_SCHED 	0x00400000#define CRYPTO_TFM_RES_BAD_BLOCK_LEN 	0x00800000#define CRYPTO_TFM_RES_BAD_FLAGS 	0x01000000 /* * Miscellaneous stuff. */#define CRYPTO_MAX_ALG_NAME		64 /* * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual * declaration) is used to ensure that the crypto_tfm context structure is * aligned correctly for the given architecture so that there are no alignment * faults for C data types.  In particular, this is required on platforms such * as arm where pointers are 32-bit aligned but there are data types such as * u64 which require 64-bit alignment. */#define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN))) struct scatterlist;struct crypto_ablkcipher;struct crypto_async_request;struct crypto_aead;struct crypto_blkcipher;struct crypto_hash;struct crypto_rng;struct crypto_tfm;struct crypto_type;struct aead_givcrypt_request;struct skcipher_givcrypt_request; typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err); struct crypto_async_request {	struct list_head list;	crypto_completion_t complete;	void *data;	struct crypto_tfm *tfm; 	u32 flags;}; struct ablkcipher_request {	struct crypto_async_request base; 	unsigned int nbytes; 	void *info; 	struct scatterlist *src;	struct scatterlist *dst; 	void *__ctx[] CRYPTO_MINALIGN_ATTR;}; /** *	struct aead_request - AEAD request *	@base: Common attributes for async crypto requests *	@assoclen: Length in bytes of associated data for authentication *	@cryptlen: Length of data to be encrypted or decrypted *	@iv: Initialisation vector *	@assoc: Associated data *	@src: Source data *	@dst: Destination data *	@__ctx: Start of private context data */struct aead_request {	struct crypto_async_request base; 	unsigned int assoclen;	unsigned int cryptlen; 	u8 *iv; 	struct scatterlist *assoc;	struct scatterlist *src;	struct scatterlist *dst; 	void *__ctx[] CRYPTO_MINALIGN_ATTR;}; struct blkcipher_desc {	struct crypto_blkcipher *tfm;	void *info;	u32 flags;}; struct cipher_desc {	struct crypto_tfm *tfm;	void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);	unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst,			     const u8 *src, unsigned int nbytes);	void *info;}; struct hash_desc {	struct crypto_hash *tfm;	u32 flags;}; /* * Algorithms: modular crypto algorithm implementations, managed * via crypto_register_alg() and crypto_unregister_alg(). */struct ablkcipher_alg {	int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,	              unsigned int keylen);	int (*encrypt)(struct ablkcipher_request *req);	int (*decrypt)(struct ablkcipher_request *req);	int (*givencrypt)(struct skcipher_givcrypt_request *req);	int (*givdecrypt)(struct skcipher_givcrypt_request *req); 	const char *geniv; 	unsigned int min_keysize;	unsigned int max_keysize;	unsigned int ivsize;}; struct aead_alg {	int (*setkey)(struct crypto_aead *tfm, const u8 *key,	              unsigned int keylen);	int (*setauthsize)(struct crypto_aead *tfm, unsigned int authsize);	int (*encrypt)(struct aead_request *req);	int (*decrypt)(struct aead_request *req);	int (*givencrypt)(struct aead_givcrypt_request *req);	int (*givdecrypt)(struct aead_givcrypt_request *req); 	const char *geniv; 	unsigned int ivsize;	unsigned int maxauthsize;}; struct blkcipher_alg {	int (*setkey)(struct crypto_tfm *tfm, const u8 *key,	              unsigned int keylen);	int (*encrypt)(struct blkcipher_desc *desc,		       struct scatterlist *dst, struct scatterlist *src,		       unsigned int nbytes);	int (*decrypt)(struct blkcipher_desc *desc,		       struct scatterlist *dst, struct scatterlist *src,		       unsigned int nbytes); 	const char *geniv; 	unsigned int min_keysize;	unsigned int max_keysize;	unsigned int ivsize;}; struct cipher_alg {	unsigned int cia_min_keysize;	unsigned int cia_max_keysize;	int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,	                  unsigned int keylen);	void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);	void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);}; struct compress_alg {	int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src,			    unsigned int slen, u8 *dst, unsigned int *dlen);	int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src,			      unsigned int slen, u8 *dst, unsigned int *dlen);}; struct rng_alg {	int (*rng_make_random)(struct crypto_rng *tfm, u8 *rdata,			       unsigned int dlen);	int (*rng_reset)(struct crypto_rng *tfm, u8 *seed, unsigned int slen); 	unsigned int seedsize;};  #define cra_ablkcipher	cra_u.ablkcipher#define cra_aead	cra_u.aead#define cra_blkcipher	cra_u.blkcipher#define cra_cipher	cra_u.cipher#define cra_compress	cra_u.compress#define cra_rng		cra_u.rng struct crypto_alg {	struct list_head cra_list;	struct list_head cra_users; 	u32 cra_flags;	unsigned int cra_blocksize;	unsigned int cra_ctxsize;	unsigned int cra_alignmask; 	int cra_priority;	atomic_t cra_refcnt; 	char cra_name[CRYPTO_MAX_ALG_NAME];	char cra_driver_name[CRYPTO_MAX_ALG_NAME]; 	const struct crypto_type *cra_type; 	union {		struct ablkcipher_alg ablkcipher;		struct aead_alg aead;		struct blkcipher_alg blkcipher;		struct cipher_alg cipher;		struct compress_alg compress;		struct rng_alg rng;	} cra_u; 	int (*cra_init)(struct crypto_tfm *tfm);	void (*cra_exit)(struct crypto_tfm *tfm);	void (*cra_destroy)(struct crypto_alg *alg);		struct module *cra_module;}; /* * Algorithm registration interface. */int crypto_register_alg(struct crypto_alg *alg);int crypto_unregister_alg(struct crypto_alg *alg);int crypto_register_algs(struct crypto_alg *algs, int count);int crypto_unregister_algs(struct crypto_alg *algs, int count); /* * Algorithm query interface. */int crypto_has_alg(const char *name, u32 type, u32 mask); /* * Transforms: user-instantiated objects which encapsulate algorithms * and core processing logic.  Managed via crypto_alloc_*() and * crypto_free_*(), as well as the various helpers below. */ struct ablkcipher_tfm {	int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,	              unsigned int keylen);	int (*encrypt)(struct ablkcipher_request *req);	int (*decrypt)(struct ablkcipher_request *req);	int (*givencrypt)(struct skcipher_givcrypt_request *req);	int (*givdecrypt)(struct skcipher_givcrypt_request *req); 	struct crypto_ablkcipher *base; 	unsigned int ivsize;	unsigned int reqsize;}; struct aead_tfm {	int (*setkey)(struct crypto_aead *tfm, const u8 *key,	              unsigned int keylen);	int (*encrypt)(struct aead_request *req);	int (*decrypt)(struct aead_request *req);	int (*givencrypt)(struct aead_givcrypt_request *req);	int (*givdecrypt)(struct aead_givcrypt_request *req); 	struct crypto_aead *base; 	unsigned int ivsize;	unsigned int authsize;	unsigned int reqsize;}; struct blkcipher_tfm {	void *iv;	int (*setkey)(struct crypto_tfm *tfm, const u8 *key,		      unsigned int keylen);	int (*encrypt)(struct blkcipher_desc *desc, struct scatterlist *dst,		       struct scatterlist *src, unsigned int nbytes);	int (*decrypt)(struct blkcipher_desc *desc, struct scatterlist *dst,		       struct scatterlist *src, unsigned int nbytes);}; struct cipher_tfm {	int (*cit_setkey)(struct crypto_tfm *tfm,	                  const u8 *key, unsigned int keylen);	void (*cit_encrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);	void (*cit_decrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);}; struct hash_tfm {	int (*init)(struct hash_desc *desc);	int (*update)(struct hash_desc *desc,		      struct scatterlist *sg, unsigned int nsg);	int (*final)(struct hash_desc *desc, u8 *out);	int (*digest)(struct hash_desc *desc, struct scatterlist *sg,		      unsigned int nsg, u8 *out);	int (*setkey)(struct crypto_hash *tfm, const u8 *key,		      unsigned int keylen);	unsigned int digestsize;}; struct compress_tfm {	int (*cot_compress)(struct crypto_tfm *tfm,	                    const u8 *src, unsigned int slen,	                    u8 *dst, unsigned int *dlen);	int (*cot_decompress)(struct crypto_tfm *tfm,	                      const u8 *src, unsigned int slen,	                      u8 *dst, unsigned int *dlen);}; struct rng_tfm {	int (*rng_gen_random)(struct crypto_rng *tfm, u8 *rdata,			      unsigned int dlen);	int (*rng_reset)(struct crypto_rng *tfm, u8 *seed, unsigned int slen);}; #define crt_ablkcipher	crt_u.ablkcipher#define crt_aead	crt_u.aead#define crt_blkcipher	crt_u.blkcipher#define crt_cipher	crt_u.cipher#define crt_hash	crt_u.hash#define crt_compress	crt_u.compress#define crt_rng		crt_u.rng struct crypto_tfm { 	u32 crt_flags;		union {		struct ablkcipher_tfm ablkcipher;		struct aead_tfm aead;		struct blkcipher_tfm blkcipher;		struct cipher_tfm cipher;		struct hash_tfm hash;		struct compress_tfm compress;		struct rng_tfm rng;	} crt_u; 	void (*exit)(struct crypto_tfm *tfm);		struct crypto_alg *__crt_alg; 	void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;}; struct crypto_ablkcipher {	struct crypto_tfm base;}; struct crypto_aead {	struct crypto_tfm base;}; struct crypto_blkcipher {	struct crypto_tfm base;}; struct crypto_cipher {	struct crypto_tfm base;}; struct crypto_comp {	struct crypto_tfm base;}; struct crypto_hash {	struct crypto_tfm base;}; struct crypto_rng {	struct crypto_tfm base;}; enum {	CRYPTOA_UNSPEC,	CRYPTOA_ALG,	CRYPTOA_TYPE,	CRYPTOA_U32,	__CRYPTOA_MAX,}; #define CRYPTOA_MAX (__CRYPTOA_MAX - 1) /* Maximum number of (rtattr) parameters for each template. */#define CRYPTO_MAX_ATTRS 32 struct crypto_attr_alg {	char name[CRYPTO_MAX_ALG_NAME];}; struct crypto_attr_type {	u32 type;	u32 mask;}; struct crypto_attr_u32 {	u32 num;}; /*  * Transform user interface. */ struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask);void crypto_destroy_tfm(void *mem, struct crypto_tfm *tfm); static inline void crypto_free_tfm(struct crypto_tfm *tfm){	return crypto_destroy_tfm(tfm, tfm);} int alg_test(const char *driver, const char *alg, u32 type, u32 mask);

Lines 1–500 of 1287. Load more