[mirror_ubuntu-bionic-kernel.git] / net / mac80211 / aes_gcm.c

/*
 * Copyright 2014-2015, Qualcomm Atheros, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/err.h>
#include <crypto/aead.h>

#include <net/mac80211.h>
#include "key.h"
#include "aes_gcm.h"

int ieee80211_aes_gcm_encrypt(struct crypto_aead *tfm, u8 *j_0, u8 *aad,
			      u8 *data, size_t data_len, u8 *mic)
{
	struct scatterlist sg[3];
	struct aead_request *aead_req;
	int reqsize = sizeof(*aead_req) + crypto_aead_reqsize(tfm);
	u8 *__aad;

	aead_req = kzalloc(reqsize + GCM_AAD_LEN, GFP_ATOMIC);
	if (!aead_req)
		return -ENOMEM;

	__aad = (u8 *)aead_req + reqsize;
	memcpy(__aad, aad, GCM_AAD_LEN);

	sg_init_table(sg, 3);
	sg_set_buf(&sg[0], &__aad[2], be16_to_cpup((__be16 *)__aad));
	sg_set_buf(&sg[1], data, data_len);
	sg_set_buf(&sg[2], mic, IEEE80211_GCMP_MIC_LEN);

	aead_request_set_tfm(aead_req, tfm);
	aead_request_set_crypt(aead_req, sg, sg, data_len, j_0);
	aead_request_set_ad(aead_req, sg[0].length);

	crypto_aead_encrypt(aead_req);
	kzfree(aead_req);
	return 0;
}

int ieee80211_aes_gcm_decrypt(struct crypto_aead *tfm, u8 *j_0, u8 *aad,
			      u8 *data, size_t data_len, u8 *mic)
{
	struct scatterlist sg[3];
	struct aead_request *aead_req;
	int reqsize = sizeof(*aead_req) + crypto_aead_reqsize(tfm);
	u8 *__aad;
	int err;

	if (data_len == 0)
		return -EINVAL;

	aead_req = kzalloc(reqsize + GCM_AAD_LEN, GFP_ATOMIC);
	if (!aead_req)
		return -ENOMEM;

	__aad = (u8 *)aead_req + reqsize;
	memcpy(__aad, aad, GCM_AAD_LEN);

	sg_init_table(sg, 3);
	sg_set_buf(&sg[0], &__aad[2], be16_to_cpup((__be16 *)__aad));
	sg_set_buf(&sg[1], data, data_len);
	sg_set_buf(&sg[2], mic, IEEE80211_GCMP_MIC_LEN);

	aead_request_set_tfm(aead_req, tfm);
	aead_request_set_crypt(aead_req, sg, sg,
			       data_len + IEEE80211_GCMP_MIC_LEN, j_0);
	aead_request_set_ad(aead_req, sg[0].length);

	err = crypto_aead_decrypt(aead_req);
	kzfree(aead_req);

	return err;
}

struct crypto_aead *ieee80211_aes_gcm_key_setup_encrypt(const u8 key[],
							size_t key_len)
{
	struct crypto_aead *tfm;
	int err;

	tfm = crypto_alloc_aead("gcm(aes)", 0, CRYPTO_ALG_ASYNC);
	if (IS_ERR(tfm))
		return tfm;

	err = crypto_aead_setkey(tfm, key, key_len);
	if (err)
		goto free_aead;
	err = crypto_aead_setauthsize(tfm, IEEE80211_GCMP_MIC_LEN);
	if (err)
		goto free_aead;

	return tfm;

free_aead:
	crypto_free_aead(tfm);
	return ERR_PTR(err);
}

void ieee80211_aes_gcm_key_free(struct crypto_aead *tfm)
{
	crypto_free_aead(tfm);
}
Commit	Line	Data
00b9cfa3 JM	1	/*
	2	* Copyright 2014-2015, Qualcomm Atheros, Inc.
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/types.h>
00b9cfa3	11	#include <linux/err.h>
d8fe0ddd	12	#include <crypto/aead.h>
00b9cfa3 JM	13
	14	#include <net/mac80211.h>
	15	#include "key.h"
	16	#include "aes_gcm.h"
	17
f4a067f9 AB	18	int ieee80211_aes_gcm_encrypt(struct crypto_aead tfm, u8 j_0, u8 *aad,
f4a067f9 AB	19	u8 data, size_t data_len, u8 mic)
00b9cfa3	20	{
957e0fe6	21	struct scatterlist sg[3];
f4a067f9 AB	22	struct aead_request *aead_req;
	23	int reqsize = sizeof(*aead_req) + crypto_aead_reqsize(tfm);
	24	u8 *__aad;
00b9cfa3	25
f4a067f9 AB	26	aead_req = kzalloc(reqsize + GCM_AAD_LEN, GFP_ATOMIC);
	27	if (!aead_req)
	28	return -ENOMEM;
00b9cfa3	29
f4a067f9 AB	30	__aad = (u8 *)aead_req + reqsize;
f4a067f9 AB	31	memcpy(__aad, aad, GCM_AAD_LEN);
00b9cfa3	32
957e0fe6	33	sg_init_table(sg, 3);
f4a067f9	34	sg_set_buf(&sg[0], &__aad[2], be16_to_cpup((__be16 *)__aad));
957e0fe6 HX	35	sg_set_buf(&sg[1], data, data_len);
957e0fe6 HX	36	sg_set_buf(&sg[2], mic, IEEE80211_GCMP_MIC_LEN);
00b9cfa3 JM	37
00b9cfa3 JM	38	aead_request_set_tfm(aead_req, tfm);
957e0fe6 HX	39	aead_request_set_crypt(aead_req, sg, sg, data_len, j_0);
957e0fe6 HX	40	aead_request_set_ad(aead_req, sg[0].length);
00b9cfa3 JM	41
00b9cfa3 JM	42	crypto_aead_encrypt(aead_req);
f4a067f9 AB	43	kzfree(aead_req);
f4a067f9 AB	44	return 0;
00b9cfa3 JM	45	}
	46
	47	int ieee80211_aes_gcm_decrypt(struct crypto_aead tfm, u8 j_0, u8 *aad,
	48	u8 data, size_t data_len, u8 mic)
	49	{
957e0fe6	50	struct scatterlist sg[3];
f4a067f9 AB	51	struct aead_request *aead_req;
	52	int reqsize = sizeof(*aead_req) + crypto_aead_reqsize(tfm);
	53	u8 *__aad;
	54	int err;
00b9cfa3 JM	55
	56	if (data_len == 0)
	57	return -EINVAL;
	58
f4a067f9 AB	59	aead_req = kzalloc(reqsize + GCM_AAD_LEN, GFP_ATOMIC);
	60	if (!aead_req)
	61	return -ENOMEM;
	62
	63	__aad = (u8 *)aead_req + reqsize;
	64	memcpy(__aad, aad, GCM_AAD_LEN);
00b9cfa3	65
957e0fe6	66	sg_init_table(sg, 3);
f4a067f9	67	sg_set_buf(&sg[0], &__aad[2], be16_to_cpup((__be16 *)__aad));
957e0fe6 HX	68	sg_set_buf(&sg[1], data, data_len);
957e0fe6 HX	69	sg_set_buf(&sg[2], mic, IEEE80211_GCMP_MIC_LEN);
00b9cfa3 JM	70
00b9cfa3 JM	71	aead_request_set_tfm(aead_req, tfm);
957e0fe6	72	aead_request_set_crypt(aead_req, sg, sg,
00b9cfa3	73	data_len + IEEE80211_GCMP_MIC_LEN, j_0);
957e0fe6	74	aead_request_set_ad(aead_req, sg[0].length);
00b9cfa3	75
f4a067f9 AB	76	err = crypto_aead_decrypt(aead_req);
	77	kzfree(aead_req);
	78
	79	return err;
00b9cfa3 JM	80	}
	81
	82	struct crypto_aead *ieee80211_aes_gcm_key_setup_encrypt(const u8 key[],
	83	size_t key_len)
	84	{
	85	struct crypto_aead *tfm;
	86	int err;
	87
	88	tfm = crypto_alloc_aead("gcm(aes)", 0, CRYPTO_ALG_ASYNC);
	89	if (IS_ERR(tfm))
	90	return tfm;
	91
	92	err = crypto_aead_setkey(tfm, key, key_len);
07862e13 JB	93	if (err)
	94	goto free_aead;
	95	err = crypto_aead_setauthsize(tfm, IEEE80211_GCMP_MIC_LEN);
	96	if (err)
	97	goto free_aead;
	98
	99	return tfm;
00b9cfa3	100
07862e13	101	free_aead:
00b9cfa3 JM	102	crypto_free_aead(tfm);
	103	return ERR_PTR(err);
	104	}
	105
	106	void ieee80211_aes_gcm_key_free(struct crypto_aead *tfm)
	107	{
	108	crypto_free_aead(tfm);
	109	}