Release 4.11 crypto/gcm.c

Directory: crypto
/*
 * GCM: Galois/Counter Mode.
 *
 * Copyright (c) 2007 Nokia Siemens Networks - Mikko Herranen <mh1@iki.fi>
 *
 * 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 <crypto/gf128mul.h>
#include <crypto/internal/aead.h>
#include <crypto/internal/skcipher.h>
#include <crypto/internal/hash.h>
#include <crypto/null.h>
#include <crypto/scatterwalk.h>
#include <crypto/hash.h>
#include "internal.h"
#include <linux/completion.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>


struct gcm_instance_ctx {
	
struct crypto_skcipher_spawn ctr;
	
struct crypto_ahash_spawn ghash;
};


struct crypto_gcm_ctx {
	
struct crypto_skcipher *ctr;
	
struct crypto_ahash *ghash;
};


struct crypto_rfc4106_ctx {
	
struct crypto_aead *child;
	
u8 nonce[4];
};


struct crypto_rfc4106_req_ctx {
	
struct scatterlist src[3];
	
struct scatterlist dst[3];
	
struct aead_request subreq;
};


struct crypto_rfc4543_instance_ctx {
	
struct crypto_aead_spawn aead;
};


struct crypto_rfc4543_ctx {
	
struct crypto_aead *child;
	
struct crypto_skcipher *null;
	
u8 nonce[4];
};


struct crypto_rfc4543_req_ctx {
	
struct aead_request subreq;
};


struct crypto_gcm_ghash_ctx {
	
unsigned int cryptlen;
	
struct scatterlist *src;
	
int (*complete)(struct aead_request *req, u32 flags);
};


struct crypto_gcm_req_priv_ctx {
	
u8 iv[16];
	
u8 auth_tag[16];
	
u8 iauth_tag[16];
	
struct scatterlist src[3];
	
struct scatterlist dst[3];
	
struct scatterlist sg;
	
struct crypto_gcm_ghash_ctx ghash_ctx;
	union {
		
struct ahash_request ahreq;
		
struct skcipher_request skreq;
	} 
u;
};


struct crypto_gcm_setkey_result {
	
int err;
	
struct completion completion;
};

static struct {
	
u8 buf[16];
	
struct scatterlist sg;
} 
*gcm_zeroes;

static int crypto_rfc4543_copy_src_to_dst(struct aead_request *req, bool enc);



static inline struct crypto_gcm_req_priv_ctx *crypto_gcm_reqctx(
	struct aead_request *req)
{
	unsigned long align = crypto_aead_alignmask(crypto_aead_reqtfm(req));

	return (void *)PTR_ALIGN((u8 *)aead_request_ctx(req), align + 1);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 47 100.00% 1 100.00%
Total 47 100.00% 1 100.00%



static void crypto_gcm_setkey_done(struct crypto_async_request *req, int err)
{
	struct crypto_gcm_setkey_result *result = req->data;

	if (err == -EINPROGRESS)
		return;

	result->err = err;
	complete(&result->completion);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 28 62.22% 1 50.00%
Mikko Herranen 17 37.78% 1 50.00%
Total 45 100.00% 2 100.00%



static int crypto_gcm_setkey(struct crypto_aead *aead, const u8 *key,
			     unsigned int keylen)
{
	struct crypto_gcm_ctx *ctx = crypto_aead_ctx(aead);
	struct crypto_ahash *ghash = ctx->ghash;
	struct crypto_skcipher *ctr = ctx->ctr;
	struct {
		be128 hash;
		u8 iv[16];

		struct crypto_gcm_setkey_result result;

		struct scatterlist sg[1];
		struct skcipher_request req;
	} *data;
	int err;

	crypto_skcipher_clear_flags(ctr, CRYPTO_TFM_REQ_MASK);
	crypto_skcipher_set_flags(ctr, crypto_aead_get_flags(aead) &
				       CRYPTO_TFM_REQ_MASK);
	err = crypto_skcipher_setkey(ctr, key, keylen);
	crypto_aead_set_flags(aead, crypto_skcipher_get_flags(ctr) &
				    CRYPTO_TFM_RES_MASK);
	if (err)
		return err;

	data = kzalloc(sizeof(*data) + crypto_skcipher_reqsize(ctr),
		       GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	init_completion(&data->result.completion);
	sg_init_one(data->sg, &data->hash, sizeof(data->hash));
	skcipher_request_set_tfm(&data->req, ctr);
	skcipher_request_set_callback(&data->req, CRYPTO_TFM_REQ_MAY_SLEEP |
						  CRYPTO_TFM_REQ_MAY_BACKLOG,
				      crypto_gcm_setkey_done,
				      &data->result);
	skcipher_request_set_crypt(&data->req, data->sg, data->sg,
				   sizeof(data->hash), data->iv);

	err = crypto_skcipher_encrypt(&data->req);
	if (err == -EINPROGRESS || err == -EBUSY) {
		err = wait_for_completion_interruptible(
			&data->result.completion);
		if (!err)
			err = data->result.err;
	}

	if (err)
		goto out;

	crypto_ahash_clear_flags(ghash, CRYPTO_TFM_REQ_MASK);
	crypto_ahash_set_flags(ghash, crypto_aead_get_flags(aead) &
			       CRYPTO_TFM_REQ_MASK);
	err = crypto_ahash_setkey(ghash, (u8 *)&data->hash, sizeof(be128));
	crypto_aead_set_flags(aead, crypto_ahash_get_flags(ghash) &
			      CRYPTO_TFM_RES_MASK);

out:
	kzfree(data);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 302 83.89% 1 20.00%
Mikko Herranen 38 10.56% 1 20.00%
Herbert Xu 19 5.28% 2 40.00%
Ondrej Mosnáček 1 0.28% 1 20.00%
Total 360 100.00% 5 100.00%



static int crypto_gcm_setauthsize(struct crypto_aead *tfm,
				  unsigned int authsize)
{
	switch (authsize) {
	case 4:
	case 8:
	case 12:
	case 13:
	case 14:
	case 15:
	case 16:
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%



static void crypto_gcm_init_common(struct aead_request *req)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	__be32 counter = cpu_to_be32(1);
	struct scatterlist *sg;

	memset(pctx->auth_tag, 0, sizeof(pctx->auth_tag));
	memcpy(pctx->iv, req->iv, 12);
	memcpy(pctx->iv + 12, &counter, 4);

	sg_init_table(pctx->src, 3);
	sg_set_buf(pctx->src, pctx->auth_tag, sizeof(pctx->auth_tag));
	sg = scatterwalk_ffwd(pctx->src + 1, req->src, req->assoclen);
	if (sg != pctx->src + 1)
		sg_chain(pctx->src, 2, sg);

	if (req->src != req->dst) {
		sg_init_table(pctx->dst, 3);
		sg_set_buf(pctx->dst, pctx->auth_tag, sizeof(pctx->auth_tag));
		sg = scatterwalk_ffwd(pctx->dst + 1, req->dst, req->assoclen);
		if (sg != pctx->dst + 1)
			sg_chain(pctx->dst, 2, sg);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 156 69.96% 1 25.00%
Herbert Xu 64 28.70% 1 25.00%
Dan J Williams 2 0.90% 1 25.00%
Mikko Herranen 1 0.45% 1 25.00%
Total 223 100.00% 4 100.00%



static void crypto_gcm_init_crypt(struct aead_request *req,
				  unsigned int cryptlen)
{
	struct crypto_aead *aead = crypto_aead_reqtfm(req);
	struct crypto_gcm_ctx *ctx = crypto_aead_ctx(aead);
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct skcipher_request *skreq = &pctx->u.skreq;
	struct scatterlist *dst;

	dst = req->src == req->dst ? pctx->src : pctx->dst;

	skcipher_request_set_tfm(skreq, ctx->ctr);
	skcipher_request_set_crypt(skreq, pctx->src, dst,
				     cryptlen + sizeof(pctx->auth_tag),
				     pctx->iv);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 105 92.92% 2 50.00%
Huang Ying 7 6.19% 1 25.00%
Mikko Herranen 1 0.88% 1 25.00%
Total 113 100.00% 4 100.00%



static inline unsigned int gcm_remain(unsigned int len)
{
	len &= 0xfU;
	return len ? 16 - len : 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 21 84.00% 1 50.00%
Huang Ying 4 16.00% 1 50.00%
Total 25 100.00% 2 100.00%

static void gcm_hash_len_done(struct crypto_async_request *areq, int err);



static int gcm_hash_update(struct aead_request *req,
			   crypto_completion_t compl,
			   struct scatterlist *src,
			   unsigned int len, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct ahash_request *ahreq = &pctx->u.ahreq;

	ahash_request_set_callback(ahreq, flags, compl, req);
	ahash_request_set_crypt(ahreq, src, NULL, len);

	return crypto_ahash_update(ahreq);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 34 44.74% 1 25.00%
Mikko Herranen 26 34.21% 1 25.00%
Herbert Xu 14 18.42% 1 25.00%
Mark D Rustad 2 2.63% 1 25.00%
Total 76 100.00% 4 100.00%



static int gcm_hash_remain(struct aead_request *req,
			   unsigned int remain,
			   crypto_completion_t compl, u32 flags)
{
	return gcm_hash_update(req, compl, &gcm_zeroes->sg, remain, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 25 65.79% 1 25.00%
Herbert Xu 9 23.68% 1 25.00%
Mikko Herranen 2 5.26% 1 25.00%
Mark D Rustad 2 5.26% 1 25.00%
Total 38 100.00% 4 100.00%



static int gcm_hash_len(struct aead_request *req, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct ahash_request *ahreq = &pctx->u.ahreq;
	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;
	u128 lengths;

	lengths.a = cpu_to_be64(req->assoclen * 8);
	lengths.b = cpu_to_be64(gctx->cryptlen * 8);
	memcpy(pctx->iauth_tag, &lengths, 16);
	sg_init_one(&pctx->sg, pctx->iauth_tag, 16);
	ahash_request_set_callback(ahreq, flags, gcm_hash_len_done, req);
	ahash_request_set_crypt(ahreq, &pctx->sg,
				pctx->iauth_tag, sizeof(lengths));

	return crypto_ahash_finup(ahreq);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 109 79.56% 1 33.33%
Herbert Xu 19 13.87% 1 33.33%
Mikko Herranen 9 6.57% 1 33.33%
Total 137 100.00% 3 100.00%



static int gcm_hash_len_continue(struct aead_request *req, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;

	return gctx->complete(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 25 56.82% 2 50.00%
Herbert Xu 15 34.09% 1 25.00%
Mikko Herranen 4 9.09% 1 25.00%
Total 44 100.00% 4 100.00%



static void gcm_hash_len_done(struct crypto_async_request *areq, int err)
{
	struct aead_request *req = areq->data;

	if (err)
		goto out;

	err = gcm_hash_len_continue(req, 0);
	if (err == -EINPROGRESS)
		return;

out:
	aead_request_complete(req, err);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 24 42.86% 2 50.00%
Mikko Herranen 23 41.07% 1 25.00%
Herbert Xu 9 16.07% 1 25.00%
Total 56 100.00% 4 100.00%



static int gcm_hash_crypt_remain_continue(struct aead_request *req, u32 flags)
{
	return gcm_hash_len(req, flags) ?:
	       gcm_hash_len_continue(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 17 56.67% 1 33.33%
Mikko Herranen 8 26.67% 1 33.33%
Huang Ying 5 16.67% 1 33.33%
Total 30 100.00% 3 100.00%



static void gcm_hash_crypt_remain_done(struct crypto_async_request *areq,
				       int err)
{
	struct aead_request *req = areq->data;

	if (err)
		goto out;

	err = gcm_hash_crypt_remain_continue(req, 0);
	if (err == -EINPROGRESS)
		return;

out:
	aead_request_complete(req, err);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 28 50.00% 2 40.00%
Herbert Xu 20 35.71% 2 40.00%
Mikko Herranen 8 14.29% 1 20.00%
Total 56 100.00% 5 100.00%



static int gcm_hash_crypt_continue(struct aead_request *req, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;
	unsigned int remain;

	remain = gcm_remain(gctx->cryptlen);
	if (remain)
		return gcm_hash_remain(req, remain,
				       gcm_hash_crypt_remain_done, flags) ?:
		       gcm_hash_crypt_remain_continue(req, flags);

	return gcm_hash_crypt_remain_continue(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 36 45.57% 2 50.00%
Herbert Xu 22 27.85% 1 25.00%
Mikko Herranen 21 26.58% 1 25.00%
Total 79 100.00% 4 100.00%



static void gcm_hash_crypt_done(struct crypto_async_request *areq, int err)
{
	struct aead_request *req = areq->data;

	if (err)
		goto out;

	err = gcm_hash_crypt_continue(req, 0);
	if (err == -EINPROGRESS)
		return;

out:
	aead_request_complete(req, err);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 28 50.00% 2 50.00%
Huang Ying 28 50.00% 2 50.00%
Total 56 100.00% 4 100.00%



static int gcm_hash_assoc_remain_continue(struct aead_request *req, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;

	if (gctx->cryptlen)
		return gcm_hash_update(req, gcm_hash_crypt_done,
				       gctx->src, gctx->cryptlen, flags) ?:
		       gcm_hash_crypt_continue(req, flags);

	return gcm_hash_crypt_remain_continue(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 43 58.11% 2 50.00%
Herbert Xu 31 41.89% 2 50.00%
Total 74 100.00% 4 100.00%



static void gcm_hash_assoc_remain_done(struct crypto_async_request *areq,
				       int err)
{
	struct aead_request *req = areq->data;

	if (err)
		goto out;

	err = gcm_hash_assoc_remain_continue(req, 0);
	if (err == -EINPROGRESS)
		return;

out:
	aead_request_complete(req, err);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 28 50.00% 2 50.00%
Herbert Xu 27 48.21% 1 25.00%
Mikko Herranen 1 1.79% 1 25.00%
Total 56 100.00% 4 100.00%



static int gcm_hash_assoc_continue(struct aead_request *req, u32 flags)
{
	unsigned int remain;

	remain = gcm_remain(req->assoclen);
	if (remain)
		return gcm_hash_remain(req, remain,
				       gcm_hash_assoc_remain_done, flags) ?:
		       gcm_hash_assoc_remain_continue(req, flags);

	return gcm_hash_assoc_remain_continue(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 27 45.76% 2 40.00%
Herbert Xu 25 42.37% 2 40.00%
Mikko Herranen 7 11.86% 1 20.00%
Total 59 100.00% 5 100.00%



static void gcm_hash_assoc_done(struct crypto_async_request *areq, int err)
{
	struct aead_request *req = areq->data;

	if (err)
		goto out;

	err = gcm_hash_assoc_continue(req, 0);
	if (err == -EINPROGRESS)
		return;

out:
	aead_request_complete(req, err);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 35 62.50% 2 50.00%
Huang Ying 21 37.50% 2 50.00%
Total 56 100.00% 4 100.00%



static int gcm_hash_init_continue(struct aead_request *req, u32 flags)
{
	if (req->assoclen)
		return gcm_hash_update(req, gcm_hash_assoc_done,
				       req->src, req->assoclen, flags) ?:
		       gcm_hash_assoc_continue(req, flags);

	return gcm_hash_assoc_remain_continue(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Huang Ying 34 62.96% 2 50.00%
Herbert Xu 20 37.04% 2 50.00%
Total 54 100.00% 4 100.00%



static void gcm_hash_init_done(struct crypto_async_request *areq, int err)
{
	struct aead_request *req = areq->data;

	if (err)
		goto out;

	err = gcm_hash_init_continue(req, 0);
	if (err == -EINPROGRESS)
		return;

out:
	aead_request_complete(req, err);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 28 50.00% 2 50.00%
Huang Ying 28 50.00% 2 50.00%
Total 56 100.00% 4 100.00%



static int gcm_hash(struct aead_request *req, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct ahash_request *ahreq = &pctx->u.ahreq;
	struct crypto_gcm_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));

	ahash_request_set_tfm(ahreq, ctx->ghash);

	ahash_request_set_callback(ahreq, flags, gcm_hash_init_done, req);
	return crypto_ahash_init(ahreq) ?:
	       gcm_hash_init_continue(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 34 40.96% 2 50.00%
Huang Ying 25 30.12% 1 25.00%
Mikko Herranen 24 28.92% 1 25.00%
Total 83 100.00% 4 100.00%



static int gcm_enc_copy_hash(struct aead_request *req, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct crypto_aead *aead = crypto_aead_reqtfm(req);
	u8 *auth_tag = pctx->auth_tag;

	crypto_xor(auth_tag, pctx->iauth_tag, 16);
	scatterwalk_map_and_copy(auth_tag, req->dst,
				 req->assoclen + req->cryptlen,
				 crypto_aead_authsize(aead), 1);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 64 80.00% 2 50.00%
Huang Ying 9 11.25% 1 25.00%
Mikko Herranen 7 8.75% 1 25.00%
Total 80 100.00% 4 100.00%



static int gcm_encrypt_continue(struct aead_request *req, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;

	gctx->src = sg_next(req->src == req->dst ? pctx->src : pctx->dst);
	gctx->cryptlen = req->cryptlen;
	gctx->complete = gcm_enc_copy_hash;

	return gcm_hash(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 63 79.75% 2 50.00%
Huang Ying 11 13.92% 1 25.00%
Mikko Herranen 5 6.33% 1 25.00%
Total 79 100.00% 4 100.00%



static void gcm_encrypt_done(struct crypto_async_request *areq, int err)
{
	struct aead_request *req = areq->data;

	if (err)
		goto out;

	err = gcm_encrypt_continue(req, 0);
	if (err == -EINPROGRESS)
		return;

out:
	aead_request_complete(req, err);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 37 66.07% 1 33.33%
Huang Ying 14 25.00% 1 33.33%
Mikko Herranen 5 8.93% 1 33.33%
Total 56 100.00% 3 100.00%



static int crypto_gcm_encrypt(struct aead_request *req)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct skcipher_request *skreq = &pctx->u.skreq;
	u32 flags = aead_request_flags(req);

	crypto_gcm_init_common(req);
	crypto_gcm_init_crypt(req, req->cryptlen);
	skcipher_request_set_callback(skreq, flags, gcm_encrypt_done, req);

	return crypto_skcipher_encrypt(skreq) ?:
	       gcm_encrypt_continue(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 53 66.25% 3 60.00%
Mikko Herranen 23 28.75% 1 20.00%
Huang Ying 4 5.00% 1 20.00%
Total 80 100.00% 5 100.00%



static int crypto_gcm_verify(struct aead_request *req)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct crypto_aead *aead = crypto_aead_reqtfm(req);
	u8 *auth_tag = pctx->auth_tag;
	u8 *iauth_tag = pctx->iauth_tag;
	unsigned int authsize = crypto_aead_authsize(aead);
	unsigned int cryptlen = req->cryptlen - authsize;

	crypto_xor(auth_tag, iauth_tag, 16);
	scatterwalk_map_and_copy(iauth_tag, req->src,
				 req->assoclen + cryptlen, authsize, 0);
	return crypto_memneq(iauth_tag, auth_tag, authsize) ? -EBADMSG : 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 87 79.82% 2 40.00%
Huang Ying 20 18.35% 2 40.00%
Mikko Herranen 2 1.83% 1 20.00%
Total 109 100.00% 5 100.00%



static void gcm_decrypt_done(struct crypto_async_request *areq, int err)
{
	struct aead_request *req = areq->data;

	if (!err)
		err = crypto_gcm_verify(req);

	aead_request_complete(req, err);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 36 85.71% 3 75.00%
Huang Ying 6 14.29% 1 25.00%
Total 42 100.00% 4 100.00%



static int gcm_dec_hash_continue(struct aead_request *req, u32 flags)
{
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct skcipher_request *skreq = &pctx->u.skreq;
	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;

	crypto_gcm_init_crypt(req, gctx->cryptlen);
	skcipher_request_set_callback(skreq, flags, gcm_decrypt_done, req);
	return crypto_skcipher_decrypt(skreq) ?: crypto_gcm_verify(req);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 62 79.49% 4 66.67%
Huang Ying 14 17.95% 1 16.67%
Mikko Herranen 2 2.56% 1 16.67%
Total 78 100.00% 6 100.00%



static int crypto_gcm_decrypt(struct aead_request *req)
{
	struct crypto_aead *aead = crypto_aead_reqtfm(req);
	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;
	unsigned int authsize = crypto_aead_authsize(aead);
	unsigned int cryptlen = req->cryptlen;
	u32 flags = aead_request_flags(req);

	cryptlen -= authsize;

	crypto_gcm_init_common(req);

	gctx->src = sg_next(pctx->src);
	gctx->cryptlen = cryptlen;
	gctx->complete = gcm_dec_hash_continue;

	return gcm_hash(req, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 86 81.13% 3 75.00%
Mikko Herranen 20 18.87% 1 25.00%
Total 106 100.00% 4 100.00%



static int crypto_gcm_init_tfm(struct crypto_aead *tfm)
{
	struct aead_instance *inst = aead_alg_instance(tfm);
	struct gcm_instance_ctx *ictx = aead_instance_ctx(inst);
	struct crypto_gcm_ctx *ctx = crypto_aead_ctx(tfm);
	struct crypto_skcipher *ctr;
	struct crypto_ahash *ghash;
	unsigned long align;
	int err;

	ghash = crypto_spawn_ahash(&ictx->ghash);
	if (IS_ERR(ghash))
		return PTR_ERR(ghash);

	ctr = crypto_spawn_skcipher(&ictx->ctr);
	err = PTR_ERR(ctr);
	if (IS_ERR(ctr))
		goto err_free_hash;

	ctx->ctr = ctr;
	ctx->ghash = ghash;

	align = crypto_aead_alignmask(tfm);
	align &= ~(crypto_tfm_ctx_alignment() - 1);
	crypto_aead_set_reqsize(tfm,
		align + offsetof(struct crypto_gcm_req_priv_ctx, u) +
		max(sizeof(struct skcipher_request) +
		    crypto_skcipher_reqsize(ctr),
		    sizeof(struct ahash_request) +
		    crypto_ahash_reqsize(ghash)));

	return 0;

err_free_hash:
	crypto_free_ahash(ghash);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 80 42.11% 6 60.00%
Huang Ying 71 37.37% 2 20.00%
Mikko Herranen 38 20.00% 1 10.00%
Eric Biggers 1 0.53% 1 10.00%
Total 190 100.00% 10 100.00%



static void crypto_gcm_exit_tfm(struct crypto_aead *tfm)
{
	struct crypto_gcm_ctx *ctx = crypto_aead_ctx(tfm);

	crypto_free_ahash(ctx->ghash);
	crypto_free_skcipher(ctx->ctr);
}

Contributors
Person Tokens Prop Commits CommitProp
Mikko Herranen 30 85.71% 1 25.00%
Herbert Xu 3 8.57% 2 50.00%
Huang Ying 2 5.71% 1 25.00%
Total 35 100.00% 4 100.00%



static void crypto_gcm_free(struct aead_instance *
Person	Tokens	Prop	Commits	CommitProp
Herbert Xu	47	100.00%	1	100.00%
Total	47	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 crypto/gcm.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
