// SPDX-License-Identifier: GPL-2.0
#include <linux_crypto.h>

/**
 * crypto_free_aead() - zeroize and free aead handle
 * @tfm: cipher handle to be freed
 */
void crypto_free_aead(struct crypto_aead *tfm)
{
	crypto_free_tfm(crypto_aead_tfm(tfm));
}

/**
 * DOC: Asynchronous AEAD Request Handle
 *
 * The aead_request data structure contains all pointers to data required for
 * the AEAD cipher operation. This includes the cipher handle (which can be
 * used by multiple aead_request instances), pointer to plaintext and
 * ciphertext, asynchronous callback function, etc. It acts as a handle to the
 * aead_request_* API calls in a similar way as AEAD handle to the
 * crypto_aead_* API calls.
 */

/**
 * crypto_aead_reqsize() - obtain size of the request data structure
 * @tfm: cipher handle
 *
 * Return: number of bytes
 */
unsigned int crypto_aead_reqsize(struct crypto_aead *tfm)
{
	return crypto_aead_crt(tfm)->reqsize;
}

/**
 * crypto_aead_encrypt() - encrypt plaintext
 * @req: reference to the aead_request handle that holds all information
 *       needed to perform the cipher operation
 *
 * Encrypt plaintext data using the aead_request handle. That data structure
 * and how it is filled with data is discussed with the aead_request_*
 * functions.
 *
 * IMPORTANT NOTE The encryption operation creates the authentication data /
 *                tag. That data is concatenated with the created ciphertext.
 *                The ciphertext memory size is therefore the given number of
 *                block cipher blocks + the size defined by the
 *                crypto_aead_setauthsize invocation. The caller must ensure
 *                that sufficient memory is available for the ciphertext and
 *                the authentication tag.
 *
 * Return: 0 if the cipher operation was successful; < 0 if an error occurred
 */
int crypto_aead_encrypt(struct aead_request *req)
{
	return crypto_aead_crt(crypto_aead_reqtfm(req))->encrypt(req);
}

/**
 * crypto_aead_decrypt() - decrypt ciphertext
 * @req: reference to the ablkcipher_request handle that holds all information
 *       needed to perform the cipher operation
 *
 * Decrypt ciphertext data using the aead_request handle. That data structure
 * and how it is filled with data is discussed with the aead_request_*
 * functions.
 *
 * IMPORTANT NOTE The caller must concatenate the ciphertext followed by the
 *                authentication data / tag. That authentication data / tag
 *                must have the size defined by the crypto_aead_setauthsize
 *                invocation.
 *
 *
 * Return: 0 if the cipher operation was successful; -EBADMSG: The AEAD
 *         cipher operation performs the authentication of the data during the
 *         decryption operation. Therefore, the function returns this error if
 *         the authentication of the ciphertext was unsuccessful (i.e. the
 *         integrity of the ciphertext or the associated data was violated);
 *         < 0 if an error occurred.
 */
int crypto_aead_decrypt(struct aead_request *req)
{
	if (req->cryptlen < crypto_aead_authsize(crypto_aead_reqtfm(req)))
		return -EINVAL;

	return crypto_aead_crt(crypto_aead_reqtfm(req))->decrypt(req);
}

/**
 * aead_request_set_tfm() - update cipher handle reference in request
 * @req: request handle to be modified
 * @tfm: cipher handle that shall be added to the request handle
 *
 * Allow the caller to replace the existing aead handle in the request
 * data structure with a different one.
 */
void aead_request_set_tfm(struct aead_request *req,
		struct crypto_aead *tfm)
{
	req->base.tfm = crypto_aead_tfm(crypto_aead_crt(tfm)->base);
}


/**
 * aead_request_set_assoc() - set the associated data scatter / gather list
 * @req: request handle
 * @assoc: associated data scatter / gather list
 * @assoclen: number of bytes to process from @assoc
 *
 * For encryption, the memory is filled with the associated data. For
 * decryption, the memory must point to the associated data.
 */
void aead_request_set_assoc(struct aead_request *req,
		struct scatterlist *assoc,
		unsigned int assoclen)
{
	req->assoc = assoc;
	req->assoclen = assoclen;
}


/**
 * aead_request_set_crypt - set data buffers
 * @req: request handle
 * @src: source scatter / gather list
 * @dst: destination scatter / gather list
 * @cryptlen: number of bytes to process from @src
 * @iv: IV for the cipher operation which must comply with the IV size defined
 *      by crypto_aead_ivsize()
 *
 * Setting the source data and destination data scatter / gather lists.
 *
 * For encryption, the source is treated as the plaintext and the
 * destination is the ciphertext. For a decryption operation, the use is
 * reversed - the source is the ciphertext and the destination is the plaintext.
 *
 * IMPORTANT NOTE AEAD requires an authentication tag (MAC). For decryption,
 *                the caller must concatenate the ciphertext followed by the
 *                authentication tag and provide the entire data stream to the
 *                decryption operation (i.e. the data length used for the
 *                initialization of the scatterlist and the data length for the
 *                decryption operation is identical). For encryption, however,
 *                the authentication tag is created while encrypting the data.
 *                The destination buffer must hold sufficient space for the
 *                ciphertext and the authentication tag while the encryption
 *                invocation must only point to the plaintext data size. The
 *                following code snippet illustrates the memory usage
 *                buffer = kmalloc(ptbuflen + (enc ? authsize : 0));
 *                sg_init_one(&sg, buffer, ptbuflen + (enc ? authsize : 0));
 *                aead_request_set_crypt(req, &sg, &sg, ptbuflen, iv);
 */
void aead_request_set_crypt(struct aead_request *req,
		struct scatterlist *src,
		struct scatterlist *dst,
		unsigned int cryptlen, u8 *iv)
{
	req->src = src;
	req->dst = dst;
	req->cryptlen = cryptlen;
	req->iv = iv;
}


/**
 * crypto_alloc_cipher() - allocate single block cipher handle
 * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
 *           single block cipher
 * @type: specifies the type of the cipher
 * @mask: specifies the mask for the cipher
 *
 * Allocate a cipher handle for a single block cipher. The returned struct
 * crypto_cipher is the cipher handle that is required for any subsequent API
 * invocation for that single block cipher.
 *
 * Return: allocated cipher handle in case of success; IS_ERR() is true in case
 *         of an error, PTR_ERR() returns the error code.
 */
struct crypto_cipher *crypto_alloc_cipher(const char *alg_name,
		u32 type, u32 mask)
{
	type &= ~CRYPTO_ALG_TYPE_MASK;
	type |= CRYPTO_ALG_TYPE_CIPHER;
	mask |= CRYPTO_ALG_TYPE_MASK;

	return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask));
}

/**
 * crypto_free_cipher() - zeroize and free the single block cipher handle
 * @tfm: cipher handle to be freed
 */
void crypto_free_cipher(struct crypto_cipher *tfm)
{
	crypto_free_tfm(crypto_cipher_tfm(tfm));
}

/**
 * crypto_cipher_setkey() - set key for cipher
 * @tfm: cipher handle
 * @key: buffer holding the key
 * @keylen: length of the key in bytes
 *
 * The caller provided key is set for the single block cipher referenced by the
 * cipher handle.
 *
 * Note, the key length determines the cipher type. Many block ciphers implement
 * different cipher modes depending on the key size, such as AES-128 vs AES-192
 * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
 * is performed.
 *
 * Return: 0 if the setting of the key was successful; < 0 if an error occurred
 */
int crypto_cipher_setkey(struct crypto_cipher *tfm,
		const u8 *key, unsigned int keylen)
{
	return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm),
			key, keylen);
}

/**
 * crypto_cipher_encrypt_one() - encrypt one block of plaintext
 * @tfm: cipher handle
 * @dst: points to the buffer that will be filled with the ciphertext
 * @src: buffer holding the plaintext to be encrypted
 *
 * Invoke the encryption operation of one block. The caller must ensure that
 * the plaintext and ciphertext buffers are at least one block in size.
 */
void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
		u8 *dst, const u8 *src)
{
	crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm),
			dst, src);
}

/**
 * crypto_cipher_decrypt_one() - decrypt one block of ciphertext
 * @tfm: cipher handle
 * @dst: points to the buffer that will be filled with the plaintext
 * @src: buffer holding the ciphertext to be decrypted
 *
 * Invoke the decryption operation of one block. The caller must ensure that
 * the plaintext and ciphertext buffers are at least one block in size.
 */
void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
		u8 *dst, const u8 *src)
{
	crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm),
			dst, src);
}